From 58979d1dd280355ce823369f2eab4a346fd6ef1f Mon Sep 17 00:00:00 2001 From: Sean O'Brien <60306702+stobrien89@users.noreply.github.com> Date: Sat, 21 Nov 2026 19:17:37 -0500 Subject: [PATCH] Generate restJson1 clients with the smithy-aws-core protocol --- .../.smithy-python-manifest.json | 25 + .../rest-json-1-client/README.md | 5 + .../rest-json-1-client/pyproject.toml | 38 + .../src/restjson_client/__init__.py | 30 + .../src/restjson_client/_private/__init__.py | 0 .../src/restjson_client/_private/endpoints.py | 27 + .../src/restjson_client/_private/schemas.py | 414 ++ .../src/restjson_client/_private/schemas_0.py | 1260 +++++ .../src/restjson_client/_private/schemas_1.py | 1221 +++++ .../src/restjson_client/_private/schemas_2.py | 1347 +++++ .../src/restjson_client/_private/schemas_3.py | 1125 ++++ .../src/restjson_client/aio/__init__.py | 19 + .../src/restjson_client/aio/client.py | 3717 +++++++++++++ .../src/restjson_client/aio/config.py | 123 + .../src/restjson_client/aio/user_agent.py | 16 + .../src/restjson_client/client.py | 3717 +++++++++++++ .../src/restjson_client/config.py | 118 + .../src/restjson_client/models.py | 967 ++++ .../src/restjson_client/models.pyi | 4074 ++++++++++++++ .../src/restjson_client/py.typed | 0 .../src/restjson_client/user_agent.py | 16 + designs/codegen/client.md | 17 +- designs/codegen/snapshots.md | 12 +- ...ture-4d8e3a0814104a749462bef25fdfeda5.json | 4 + .../src/smithy_python/aws/__init__.py | 4 + .../src/smithy_python/aws/_protocols.py | 45 + .../smithy-python/src/smithy_python/cli.py | 8 +- .../src/smithy_python/clients.py | 11 +- .../tests/unit/test_client_generation.py | 35 + scripts/api-snapshot/api-rex.json | 1 + .../codegen-output-py/client-projections.json | 19 + scripts/codegen-output-py/generate.py | 29 +- .../codegen-output-py/models/provenance.json | 3 +- .../models/vectors/rest-json-1.json | 4871 +++++++++++++++++ scripts/codegen-output-py/pyrightconfig.json | 1 + .../tests/test_client_protocol_vectors.py | 250 +- scripts/verifications/import-cost.json | 2 +- 37 files changed, 23510 insertions(+), 61 deletions(-) create mode 100644 codegen-output-py/rest-json-1-client/.smithy-python-manifest.json create mode 100644 codegen-output-py/rest-json-1-client/README.md create mode 100644 codegen-output-py/rest-json-1-client/pyproject.toml create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/__init__.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/_private/__init__.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/_private/endpoints.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_0.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_1.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_2.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_3.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/aio/__init__.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/aio/client.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/aio/config.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/aio/user_agent.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/client.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/config.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/models.py create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/models.pyi create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/py.typed create mode 100644 codegen-output-py/rest-json-1-client/src/restjson_client/user_agent.py create mode 100644 packages/smithy-python/.changes/next-release/smithy-python-feature-4d8e3a0814104a749462bef25fdfeda5.json create mode 100644 packages/smithy-python/src/smithy_python/aws/_protocols.py create mode 100644 scripts/codegen-output-py/models/vectors/rest-json-1.json diff --git a/codegen-output-py/rest-json-1-client/.smithy-python-manifest.json b/codegen-output-py/rest-json-1-client/.smithy-python-manifest.json new file mode 100644 index 000000000..6d79ca97e --- /dev/null +++ b/codegen-output-py/rest-json-1-client/.smithy-python-manifest.json @@ -0,0 +1,25 @@ +{ + "files": { + "README.md": "f26a428909c3765b16b4118442845f46b92fe9e7652ddc04afbc957339500fb1", + "pyproject.toml": "cef8ac9c69250c21ed5dc19e79df1b4c62eebe2776c0ee9db124f854a6ece854", + "src/restjson_client/__init__.py": "d4cd63adc5de562e0c477522373b39f8e87e7e01a4da3255b383e5b795389e05", + "src/restjson_client/_private/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "src/restjson_client/_private/endpoints.py": "7d515fe771678e82ddbe07798d6b7e48c25c6c9bec19cec9318deb0bc5064ead", + "src/restjson_client/_private/schemas.py": "527d0349a2729f5f8bb76361e2014dbbc85daef87a94ad5bbb5a80604438acc7", + "src/restjson_client/_private/schemas_0.py": "7f999b435747c05ada33363d3af8d3c1666997bfdc226285d1bfff774b82347b", + "src/restjson_client/_private/schemas_1.py": "5cba61c8b6db99a0dd5f758c9a78525ed9926f6a8986067dc43d5e5fe7ce7086", + "src/restjson_client/_private/schemas_2.py": "7af39a649f958d781c314de6dc5d0a1c1e6bc22cf46983ba834aabb461312b83", + "src/restjson_client/_private/schemas_3.py": "1edc1721aac792698841b83674d1306b373dd42bfd575f45df07da0ba34d882a", + "src/restjson_client/aio/__init__.py": "473fc51fef9cf762ab73c2de65aabd8036c7d440c7884bf017e4a02ad7b41ec5", + "src/restjson_client/aio/client.py": "d9ae4ab21316b30caf6594f67e557b5f79f470a707c7b9b50ee66f995b380eb9", + "src/restjson_client/aio/config.py": "68ea9b1478ac71564640bb1b6983672436fae6a96e48dd1195ff9a5e26b5ee20", + "src/restjson_client/aio/user_agent.py": "8e6fb66d21c2c5e59ecf31b59db9566fb217d3f95a1af63ddcb47e637613afb9", + "src/restjson_client/client.py": "6bb2663462fa8d84569bac0ca483e828a9096b5f241467defd362014864f3744", + "src/restjson_client/config.py": "c77b84c655fa53efceff14cf46569e0872dc10999d55bdd7e0a92fc6bf8cb0ed", + "src/restjson_client/models.py": "2ef5c492a6cf5922580732d19f28df88821bf8eb2c4ffaa8339ddc2d3c9cf52d", + "src/restjson_client/models.pyi": "22ffb750b64a6640e5eac1c38a3d52465d4aab181669d59b626a5cf33171f0d2", + "src/restjson_client/py.typed": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "src/restjson_client/user_agent.py": "694266638801aaf33af2627ee4ff5b8c0d2b55e46de206bbbdcab7cf17d1c9fc" + }, + "version": 1 +} diff --git a/codegen-output-py/rest-json-1-client/README.md b/codegen-output-py/rest-json-1-client/README.md new file mode 100644 index 000000000..0974d7c32 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/README.md @@ -0,0 +1,5 @@ + + +## restjson_client Client Package + +Python client for the rest-json-1 projection diff --git a/codegen-output-py/rest-json-1-client/pyproject.toml b/codegen-output-py/rest-json-1-client/pyproject.toml new file mode 100644 index 000000000..c7551bd7f --- /dev/null +++ b/codegen-output-py/rest-json-1-client/pyproject.toml @@ -0,0 +1,38 @@ +# Code generated by smithy-python-codegen DO NOT EDIT. + +[project] +name = "restjson_client" +version = "0.0.1" +description = "Python client for the rest-json-1 projection" +readme = "README.md" +requires-python = ">=3.12" +keywords = ["smithy", "restjson_client"] +license = {text = "Apache-2.0"} +dependencies = [ + "smithy-aws-core[json]~=0.16.0", + "smithy-core~=0.13.0", + "smithy-http[aiohttp,urllib3]~=0.10.0", +] + +[build-system] +requires = [ + "hatchling", +] +build-backend = "hatchling.build" + +[tool.hatch.build.targets.wheel] +packages = [ + "src/restjson_client", +] + +[tool.pyright] +typeCheckingMode = "strict" + +[tool.ruff] +target-version = "py312" + +[tool.ruff.lint] +ignore = ["F841"] + +[tool.ruff.format] +skip-magic-trailing-comma = true diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/__init__.py b/codegen-output-py/rest-json-1-client/src/restjson_client/__init__.py new file mode 100644 index 000000000..508722438 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/__init__.py @@ -0,0 +1,30 @@ +from importlib import import_module +from typing import TYPE_CHECKING, Any + +__version__: str = "0.0.1" + +if TYPE_CHECKING: + from .aio.client import AsyncRestJsonProtocolClient + from .aio.config import AsyncRestJsonProtocolConfig + from .client import RestJsonProtocolClient + from .config import RestJsonProtocolConfig + +__all__ = [ + "AsyncRestJsonProtocolClient", + "AsyncRestJsonProtocolConfig", + "RestJsonProtocolClient", + "RestJsonProtocolConfig", +] + +_EXPORTS = { + "RestJsonProtocolClient": ".client", + "RestJsonProtocolConfig": ".config", + "AsyncRestJsonProtocolClient": ".aio.client", + "AsyncRestJsonProtocolConfig": ".aio.config", +} + + +def __getattr__(name: str) -> Any: + if name in _EXPORTS: + return getattr(import_module(_EXPORTS[name], __name__), name) + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/_private/__init__.py b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/_private/endpoints.py b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/endpoints.py new file mode 100644 index 000000000..ad3066783 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/endpoints.py @@ -0,0 +1,27 @@ +from smithy_core.endpoints import EndpointBdd + +# fmt: off +# Tags: ref=0, attr=1, call=2, list=3, map=4, error=5, endpoint=6. +BDD = EndpointBdd( + # (name, type, required, default, builtin, client_context_attribute) + parameters=( + ("endpoint", "string", False, None, "SDK::Endpoint", None), + ), + functions=("isSet",), + conditions=( + ((2, "isSet", (0, "endpoint")), None), # 0: isSet(endpoint) + ), + results=( + None, # 0: no match + (6, (0, "endpoint"), None, ()), # 1 + (5, "(default endpointRuleSet) endpoint is not set - you must configure an endpoint."), # 2 + ), + root=2, + # (condition, high, low); 1 and -1 are terminals, a negative reference is a + # complement edge, and 100_000_000 + k is result k. + nodes=( + -1, 1, -1, + 0, 100_000_001, 100_000_002, + ), +) +# fmt: on diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas.py b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas.py new file mode 100644 index 000000000..26b863de4 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas.py @@ -0,0 +1,414 @@ +from importlib import import_module + +_PARTITION_NAMES: tuple[tuple[str, ...], ...] = ( + ( + "STRING_LIST", + "STRING_SET", + "INTEGER_LIST", + "INTEGER_SET", + "DOUBLE_LIST", + "BOOLEAN_LIST", + "TIMESTAMP_LIST", + "FOO_ENUM", + "FOO_ENUM_LIST", + "INTEGER_ENUM", + "INTEGER_ENUM_LIST", + "STRING_LIST_MAP", + "ALL_QUERY_STRING_TYPES_INPUT", + "ALL_QUERY_STRING_TYPES_OUTPUT", + "ALL_QUERY_STRING_TYPES", + "CLIENT_OPTIONAL_DEFAULTS", + "COMPLEX_NESTED_ERROR_DATA", + "COMPLEX_ERROR", + "CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT", + "CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT", + "CONSTANT_AND_VARIABLE_QUERY_STRING", + "CONSTANT_QUERY_STRING_INPUT", + "CONSTANT_QUERY_STRING_OUTPUT", + "CONSTANT_QUERY_STRING", + "CONTENT_TYPE_PARAMETERS_INPUT", + "CONTENT_TYPE_PARAMETERS_OUTPUT", + "CONTENT_TYPE_PARAMETERS", + "DATE_TIME", + "DATETIME_OFFSETS_OUTPUT", + "DATETIME_OFFSETS_INPUT", + "DATETIME_OFFSETS", + "TEST_STRING_LIST", + "TEST_STRING_MAP", + "TEST_ENUM", + "TEST_INT_ENUM", + "DEFAULTS", + "DENSE_BOOLEAN_MAP", + "DENSE_NUMBER_MAP", + "DENSE_SET_MAP", + "DENSE_STRING_MAP", + "GREETING_STRUCT", + "DENSE_STRUCT_MAP", + "FAREWELL", + "DIALOG", + "DIALOG_LIST", + "DIALOG_MAP", + "DOCUMENT_VALUED_MAP", + "EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT", + "EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT", + "EMPTY_INPUT_AND_EMPTY_OUTPUT", + "FOO_ERROR", + "FRACTIONAL_SECONDS_OUTPUT", + "FRACTIONAL_SECONDS_INPUT", + "FRACTIONAL_SECONDS", + "GREETING_WITH_ERRORS_OUTPUT", + "GREETING_WITH_ERRORS_INPUT", + "GREETING_WITH_ERRORS", + "STRING_MAP", + "HTTP_EMPTY_PREFIX_HEADERS_INPUT", + "HTTP_EMPTY_PREFIX_HEADERS_OUTPUT", + "HTTP_EMPTY_PREFIX_HEADERS", + "HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT", + "HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT", + "HTTP_PREFIX_HEADERS_IN_RESPONSE", + "HTTP_PREFIX_HEADERS_INPUT", + "HTTP_PREFIX_HEADERS_OUTPUT", + "HTTP_PREFIX_HEADERS", + "HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT", + "HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT", + "HTTP_REQUEST_WITH_FLOAT_LABELS", + "HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT", + "HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT", + "HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH", + "EPOCH_SECONDS", + "HTTP_DATE", + "HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT", + "HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT", + "HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT", + "HTTP_REQUEST_WITH_LABELS_INPUT", + "HTTP_REQUEST_WITH_LABELS_OUTPUT", + "HTTP_REQUEST_WITH_LABELS", + "HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT", + "HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT", + "HTTP_REQUEST_WITH_REGEX_LITERAL", + "HTTP_RESPONSE_CODE_OUTPUT", + "HTTP_RESPONSE_CODE_INPUT", + "HTTP_RESPONSE_CODE", + "IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT", + "IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT", + "IGNORE_QUERY_PARAMS_IN_RESPONSE", + "INVALID_GREETING", + "JSON_HEADER_STRING", + "JSON_VALUE", + "MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT", + "MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT", + "MALFORMED_ACCEPT_WITH_GENERIC_STRING", + ), + ( + "JPEG_BLOB", + "MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT", + "MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT", + "MALFORMED_ACCEPT_WITH_PAYLOAD", + "MALFORMED_BLOB_INPUT", + "MALFORMED_BLOB_OUTPUT", + "MALFORMED_BLOB", + "MALFORMED_BOOLEAN_INPUT", + "MALFORMED_BOOLEAN_OUTPUT", + "MALFORMED_BOOLEAN", + "MALFORMED_BYTE_INPUT", + "MALFORMED_BYTE_OUTPUT", + "MALFORMED_BYTE", + "MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT", + "MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT", + "MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING", + "MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT", + "MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT", + "MALFORMED_CONTENT_TYPE_WITH_PAYLOAD", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT", + "MALFORMED_DOUBLE_INPUT", + "MALFORMED_DOUBLE_OUTPUT", + "MALFORMED_DOUBLE", + "MALFORMED_FLOAT_INPUT", + "MALFORMED_FLOAT_OUTPUT", + "MALFORMED_FLOAT", + "MALFORMED_INTEGER_INPUT", + "MALFORMED_INTEGER_OUTPUT", + "MALFORMED_INTEGER", + "SIMPLE_LIST", + "MALFORMED_LIST_INPUT", + "MALFORMED_LIST_OUTPUT", + "MALFORMED_LIST", + "MALFORMED_LONG_INPUT", + "MALFORMED_LONG_OUTPUT", + "MALFORMED_LONG", + "SIMPLE_MAP", + "MALFORMED_MAP_INPUT", + "MALFORMED_MAP_OUTPUT", + "MALFORMED_MAP", + "MALFORMED_REQUEST_BODY_INPUT", + "MALFORMED_REQUEST_BODY_OUTPUT", + "MALFORMED_REQUEST_BODY", + "MALFORMED_SHORT_INPUT", + "MALFORMED_SHORT_OUTPUT", + "MALFORMED_SHORT", + "MALFORMED_STRING_INPUT", + "MALFORMED_STRING_OUTPUT", + "MALFORMED_STRING", + "MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT", + "MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT", + "MALFORMED_TIMESTAMP_BODY_DATE_TIME", + "MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT", + "MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT", + "MALFORMED_TIMESTAMP_BODY_DEFAULT", + "MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT", + "MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT", + "MALFORMED_TIMESTAMP_BODY_HTTP_DATE", + "MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT", + "MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT", + "MALFORMED_TIMESTAMP_HEADER_DATE_TIME", + "MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT", + "MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT", + "MALFORMED_TIMESTAMP_HEADER_DEFAULT", + "MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT", + "MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT", + "MALFORMED_TIMESTAMP_HEADER_EPOCH", + "MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT", + "MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT", + "MALFORMED_TIMESTAMP_PATH_DEFAULT", + "MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT", + "MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT", + "MALFORMED_TIMESTAMP_PATH_EPOCH", + "MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT", + "MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT", + "MALFORMED_TIMESTAMP_PATH_HTTP_DATE", + "MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT", + "MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT", + "MALFORMED_TIMESTAMP_QUERY_DEFAULT", + "MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT", + "MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT", + "MALFORMED_TIMESTAMP_QUERY_EPOCH", + "MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT", + "MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT", + "MALFORMED_TIMESTAMP_QUERY_HTTP_DATE", + "SIMPLE_UNION", + "MALFORMED_UNION_INPUT", + "MALFORMED_UNION_OUTPUT", + "MALFORMED_UNION", + "MEDIA_TYPE_HEADER_INPUT", + "MEDIA_TYPE_HEADER_OUTPUT", + "MEDIA_TYPE_HEADER", + "RENAMED_GREETING", + "NESTED_UNION", + "MY_UNION", + "NESTED_PAYLOAD", + "NO_INPUT_AND_OUTPUT_OUTPUT", + "NO_INPUT_AND_OUTPUT_INPUT", + "NO_INPUT_AND_OUTPUT", + "OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT", + "OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT", + "OMITS_NULL_SERIALIZES_EMPTY_STRING", + ), + ( + "DOCUMENT", + "OMITS_SERIALIZING_EMPTY_LISTS_INPUT", + "OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT", + "OMITS_SERIALIZING_EMPTY_LISTS", + "OPERATION_WITH_DEFAULTS_INPUT", + "OPERATION_WITH_DEFAULTS_OUTPUT", + "OPERATION_WITH_DEFAULTS", + "TOP_LEVEL", + "OPERATION_WITH_NESTED_STRUCTURE_INPUT", + "OPERATION_WITH_NESTED_STRUCTURE_OUTPUT", + "OPERATION_WITH_NESTED_STRUCTURE", + "PAYLOAD_CONFIG", + "PLAYER_ACTION", + "POST_PLAYER_ACTION_INPUT", + "POST_PLAYER_ACTION_OUTPUT", + "POST_PLAYER_ACTION", + "UNION_WITH_JSON_NAME", + "POST_UNION_WITH_JSON_NAME_INPUT", + "POST_UNION_WITH_JSON_NAME_OUTPUT", + "POST_UNION_WITH_JSON_NAME", + "PUT_WITH_CONTENT_ENCODING_INPUT", + "PUT_WITH_CONTENT_ENCODING_OUTPUT", + "PUT_WITH_CONTENT_ENCODING", + "QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT", + "QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT", + "QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL", + "QUERY_MAP", + "QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT", + "QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT", + "QUERY_PARAMS_AS_STRING_LIST_MAP", + "QUERY_PRECEDENCE_INPUT", + "QUERY_PRECEDENCE_OUTPUT", + "QUERY_PRECEDENCE", + "RESPONSE_CODE_REQUIRED_OUTPUT", + "RESPONSE_CODE_REQUIRED_INPUT", + "RESPONSE_CODE_REQUIRED", + "SPARSE_BOOLEAN_MAP", + "SPARSE_NUMBER_MAP", + "SPARSE_SET_MAP", + "SPARSE_STRUCT_MAP", + "STRING_ENUM", + "STRUCTURE_LIST_MEMBER", + "STRUCTURE_LIST", + "TEST_CONFIG", + "UNION_PAYLOAD", + "FOO_ENUM_MAP", + "FOO_ENUM_SET", + "INTEGER_ENUM_MAP", + "INTEGER_ENUM_SET", + "NESTED_STRING_LIST", + "SPARSE_SHORT_LIST", + "SPARSE_STRING_LIST", + "SPARSE_STRING_MAP", + "TEXT_PLAIN_BLOB", + "DOCUMENT_TYPE_INPUT", + "DOCUMENT_TYPE_OUTPUT", + "DOCUMENT_TYPE", + "DOCUMENT_TYPE_AS_MAP_VALUE_INPUT", + "DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT", + "DOCUMENT_TYPE_AS_MAP_VALUE", + "DOCUMENT_TYPE_AS_PAYLOAD_INPUT", + "DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT", + "DOCUMENT_TYPE_AS_PAYLOAD", + "ENDPOINT_OPERATION_INPUT", + "ENDPOINT_OPERATION_OUTPUT", + "ENDPOINT_OPERATION", + "ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT", + "ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT", + "ENDPOINT_WITH_HOST_LABEL_OPERATION", + "HOST_WITH_PATH_OPERATION_INPUT", + "HOST_WITH_PATH_OPERATION_OUTPUT", + "HOST_WITH_PATH_OPERATION", + "HTTP_CHECKSUM_REQUIRED_INPUT", + "HTTP_CHECKSUM_REQUIRED_OUTPUT", + "HTTP_CHECKSUM_REQUIRED", + "HTTP_ENUM_PAYLOAD_INPUT", + "HTTP_ENUM_PAYLOAD_OUTPUT", + "HTTP_ENUM_PAYLOAD", + "HTTP_PAYLOAD_TRAITS_INPUT", + "HTTP_PAYLOAD_TRAITS_OUTPUT", + "HTTP_PAYLOAD_TRAITS", + "HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT", + "HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT", + "HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE", + "HTTP_PAYLOAD_WITH_STRUCTURE_INPUT", + "HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT", + "HTTP_PAYLOAD_WITH_STRUCTURE", + "HTTP_PAYLOAD_WITH_UNION_INPUT", + "HTTP_PAYLOAD_WITH_UNION_OUTPUT", + "HTTP_PAYLOAD_WITH_UNION", + "HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT", + "HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT", + "HTTP_QUERY_PARAMS_ONLY_OPERATION", + "HTTP_STRING_PAYLOAD_INPUT", + "HTTP_STRING_PAYLOAD_OUTPUT", + "HTTP_STRING_PAYLOAD", + "INPUT_AND_OUTPUT_WITH_HEADERS_INPUT", + "INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT", + "INPUT_AND_OUTPUT_WITH_HEADERS", + ), + ( + "JSON_BLOBS_INPUT", + "JSON_BLOBS_OUTPUT", + "JSON_BLOBS", + "JSON_ENUMS_INPUT", + "JSON_ENUMS_OUTPUT", + "JSON_ENUMS", + "JSON_INT_ENUMS_INPUT", + "JSON_INT_ENUMS_OUTPUT", + "JSON_INT_ENUMS", + "JSON_LISTS_INPUT", + "JSON_LISTS_OUTPUT", + "JSON_LISTS", + "JSON_MAPS_INPUT", + "JSON_MAPS_OUTPUT", + "JSON_MAPS", + "JSON_TIMESTAMPS_INPUT", + "JSON_TIMESTAMPS_OUTPUT", + "JSON_TIMESTAMPS", + "JSON_UNIONS_INPUT", + "JSON_UNIONS_OUTPUT", + "JSON_UNIONS", + "MALFORMED_ACCEPT_WITH_BODY_INPUT", + "MALFORMED_ACCEPT_WITH_BODY_OUTPUT", + "MALFORMED_ACCEPT_WITH_BODY", + "MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT", + "MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT", + "MALFORMED_CONTENT_TYPE_WITH_BODY", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY", + "NO_INPUT_AND_NO_OUTPUT_INPUT", + "NO_INPUT_AND_NO_OUTPUT_OUTPUT", + "NO_INPUT_AND_NO_OUTPUT", + "NULL_AND_EMPTY_HEADERS_CLIENT_INPUT", + "NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT", + "NULL_AND_EMPTY_HEADERS_CLIENT", + "NULL_AND_EMPTY_HEADERS_SERVER_INPUT", + "NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT", + "NULL_AND_EMPTY_HEADERS_SERVER", + "RECURSIVE_SHAPES_INPUT", + "RECURSIVE_SHAPES_OUTPUT", + "RECURSIVE_SHAPES", + "RESPONSE_CODE_HTTP_FALLBACK_INPUT", + "RESPONSE_CODE_HTTP_FALLBACK_OUTPUT", + "RESPONSE_CODE_HTTP_FALLBACK", + "SIMPLE_SCALAR_PROPERTIES_INPUT", + "SIMPLE_SCALAR_PROPERTIES_OUTPUT", + "SIMPLE_SCALAR_PROPERTIES", + "SPARSE_JSON_LISTS_INPUT", + "SPARSE_JSON_LISTS_OUTPUT", + "SPARSE_JSON_LISTS", + "SPARSE_JSON_MAPS_INPUT", + "SPARSE_JSON_MAPS_OUTPUT", + "SPARSE_JSON_MAPS", + "TEST_BODY_STRUCTURE_INPUT", + "TEST_BODY_STRUCTURE_OUTPUT", + "TEST_BODY_STRUCTURE", + "TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT", + "TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT", + "TEST_GET_NO_INPUT_NO_PAYLOAD", + "TEST_GET_NO_PAYLOAD_INPUT", + "TEST_GET_NO_PAYLOAD_OUTPUT", + "TEST_GET_NO_PAYLOAD", + "TEST_PAYLOAD_BLOB_INPUT", + "TEST_PAYLOAD_BLOB_OUTPUT", + "TEST_PAYLOAD_BLOB", + "TEST_PAYLOAD_STRUCTURE_INPUT", + "TEST_PAYLOAD_STRUCTURE_OUTPUT", + "TEST_PAYLOAD_STRUCTURE", + "TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT", + "TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT", + "TEST_POST_NO_INPUT_NO_PAYLOAD", + "TEST_POST_NO_PAYLOAD_INPUT", + "TEST_POST_NO_PAYLOAD_OUTPUT", + "TEST_POST_NO_PAYLOAD", + "TIMESTAMP_FORMAT_HEADERS_INPUT", + "TIMESTAMP_FORMAT_HEADERS_OUTPUT", + "TIMESTAMP_FORMAT_HEADERS", + "UNIT_INPUT_AND_OUTPUT_INPUT", + "UNIT_INPUT_AND_OUTPUT_OUTPUT", + "UNIT_INPUT_AND_OUTPUT", + "REST_JSON", + "RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1", + "RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2", + ), +) +_PARTITIONS = { + name: index for index, names in enumerate(_PARTITION_NAMES) for name in names +} +del _PARTITION_NAMES + + +def __getattr__(name: str): + try: + partition = _PARTITIONS[name] + except KeyError as error: + raise AttributeError(name) from error + module = import_module(f".schemas_{partition:01d}", __package__) + value = getattr(module, name) + globals()[name] = value + return value + + +def __dir__() -> list[str]: + return sorted({*globals(), *_PARTITIONS}) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_0.py b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_0.py new file mode 100644 index 000000000..fff26e14d --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_0.py @@ -0,0 +1,1260 @@ +from types import MappingProxyType + +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + +from . import schemas + +n0 = "aws.protocoltests.shared" +_s0 = "StringList" +_s1 = "member" +_s2 = "StringSet" +_s3 = "IntegerList" +_s4 = "IntegerSet" +_s5 = "DoubleList" +_s6 = "BooleanList" +_s7 = "TimestampList" +_s8 = "FooEnum" +_s9 = "FOO" +_s10 = "smithy.api#enumValue" +_s11 = "Foo" +_s12 = "BAZ" +_s13 = "Baz" +_s14 = "BAR" +_s15 = "Bar" +_s16 = "ONE" +_s17 = "1" +_s18 = "ZERO" +_s19 = "0" +_s20 = "FooEnumList" +_s21 = "IntegerEnum" +_s22 = "A" +_s23 = "B" +_s24 = "C" +_s25 = "IntegerEnumList" +_s26 = "StringListMap" +_s27 = "key" +_s28 = "value" +n1 = "aws.protocoltests.restjson" +_s29 = "AllQueryStringTypesInput" +_s30 = "smithy.synthetic#originalShapeId" +_s31 = "aws.protocoltests.restjson#AllQueryStringTypesInput" +_s32 = "smithy.api#input" +_s33 = "queryString" +_s34 = "smithy.api#httpQuery" +_s35 = "String" +_s36 = "queryStringList" +_s37 = "queryStringSet" +_s38 = "queryByte" +_s39 = "Byte" +_s40 = "queryShort" +_s41 = "Short" +_s42 = "queryInteger" +_s43 = "Integer" +_s44 = "queryIntegerList" +_s45 = "queryIntegerSet" +_s46 = "queryLong" +_s47 = "Long" +_s48 = "queryFloat" +_s49 = "Float" +_s50 = "queryDouble" +_s51 = "Double" +_s52 = "queryDoubleList" +_s53 = "queryBoolean" +_s54 = "Boolean" +_s55 = "queryBooleanList" +_s56 = "queryTimestamp" +_s57 = "Timestamp" +_s58 = "queryTimestampList" +_s59 = "queryEnum" +_s60 = "Enum" +_s61 = "queryEnumList" +_s62 = "EnumList" +_s63 = "queryIntegerEnum" +_s64 = "queryIntegerEnumList" +_s65 = "queryParamsMapOfStringList" +_s66 = "ClientOptionalDefaults" +_s67 = "smithy.api#clientOptional" +_s68 = "smithy.api#default" +_s69 = "ComplexNestedErrorData" +_s70 = "smithy.api#jsonName" +_s71 = "Fooooo" +_s72 = "ComplexError" +_s73 = "smithy.api#error" +_s74 = "client" +_s75 = "smithy.api#httpError" +_s76 = "Header" +_s77 = "smithy.api#httpHeader" +_s78 = "X-Header" +_s79 = "TopLevel" +_s80 = "Nested" +_s81 = "ConstantAndVariableQueryStringInput" +_s82 = "aws.protocoltests.restjson#ConstantAndVariableQueryStringInput" +_s83 = "baz" +_s84 = "maybeSet" +_s85 = "ConstantQueryStringInput" +_s86 = "aws.protocoltests.restjson#ConstantQueryStringInput" +_s87 = "hello" +_s88 = "ContentTypeParametersInput" +_s89 = "aws.protocoltests.restjson#ContentTypeParametersInput" +_s90 = "ContentTypeParametersOutput" +_s91 = "aws.protocoltests.restjson#ContentTypeParametersOutput" +_s92 = "smithy.api#output" +_s93 = "DateTime" +_s94 = "smithy.api#timestampFormat" +_s95 = "date-time" +_s96 = "DatetimeOffsetsOutput" +_s97 = "aws.protocoltests.restjson#DatetimeOffsetsOutput" +_s98 = "datetime" +_s99 = "TestStringList" +_s101 = "TestStringMap" +_s102 = "TestEnum" +_s103 = "TestIntEnum" +_s104 = "TWO" +_s105 = "Defaults" +_s106 = "defaultString" +_s107 = "hi" +_s108 = "defaultBoolean" +_s109 = "defaultList" +_s110 = "defaultDocumentMap" +_s111 = "defaultDocumentString" +_s112 = "defaultDocumentBoolean" +_s113 = "defaultDocumentList" +_s114 = "defaultNullDocument" +_s115 = "defaultTimestamp" +_s116 = "defaultBlob" +_s117 = "YWJj" +_s118 = "defaultByte" +_s119 = "defaultShort" +_s120 = "defaultInteger" +_s121 = "defaultLong" +_s122 = "defaultFloat" +_s123 = "defaultDouble" +_s124 = "defaultMap" +_s125 = "defaultEnum" +_s126 = "defaultIntEnum" +_s127 = "emptyString" +_s128 = "" +_s129 = "falseBoolean" +_s130 = "emptyBlob" +_s131 = "zeroByte" +_s132 = "zeroShort" +_s133 = "zeroInteger" +_s134 = "zeroLong" +_s135 = "zeroFloat" +_s136 = "zeroDouble" +_s137 = "DenseBooleanMap" +_s138 = "DenseNumberMap" +_s139 = "DenseSetMap" +_s140 = "DenseStringMap" +_s141 = "GreetingStruct" +_s142 = "DenseStructMap" +_s143 = "Farewell" +_s144 = "phrase" +_s145 = "bye" +_s146 = "Dialog" +_s147 = "language" +_s148 = "greeting" +_s149 = "farewell" +_s150 = "DialogList" +_s151 = "DialogMap" +_s152 = "DocumentValuedMap" +_s153 = "EmptyInputAndEmptyOutputInput" +_s154 = "aws.protocoltests.restjson#EmptyInputAndEmptyOutputInput" +_s155 = "EmptyInputAndEmptyOutputOutput" +_s156 = "aws.protocoltests.restjson#EmptyInputAndEmptyOutputOutput" +_s157 = "FooError" +_s158 = "server" +_s159 = "FractionalSecondsOutput" +_s160 = "aws.protocoltests.restjson#FractionalSecondsOutput" +_s161 = "GreetingWithErrorsOutput" +_s162 = "aws.protocoltests.restjson#GreetingWithErrorsOutput" +_s163 = "X-Greeting" +_s164 = "StringMap" +_s165 = "HttpEmptyPrefixHeadersInput" +_s166 = "aws.protocoltests.restjson#HttpEmptyPrefixHeadersInput" +_s167 = "prefixHeaders" +_s168 = "smithy.api#httpPrefixHeaders" +_s169 = "specificHeader" +_s170 = "HttpEmptyPrefixHeadersOutput" +_s171 = "aws.protocoltests.restjson#HttpEmptyPrefixHeadersOutput" +_s172 = "HttpPrefixHeadersInResponseInput" +_s173 = "aws.protocoltests.restjson#HttpPrefixHeadersInResponseInput" +_s174 = "HttpPrefixHeadersInResponseOutput" +_s175 = "aws.protocoltests.restjson#HttpPrefixHeadersInResponseOutput" +_s176 = "HttpPrefixHeadersInput" +_s177 = "aws.protocoltests.restjson#HttpPrefixHeadersInput" +_s178 = "foo" +_s179 = "x-foo" +_s180 = "fooMap" +_s181 = "x-foo-" +_s182 = "HttpPrefixHeadersOutput" +_s183 = "aws.protocoltests.restjson#HttpPrefixHeadersOutput" +_s184 = "HttpRequestWithFloatLabelsInput" +_s185 = "aws.protocoltests.restjson#HttpRequestWithFloatLabelsInput" +_s186 = "float" +_s187 = "double" +_s188 = "HttpRequestWithGreedyLabelInPathInput" +_s189 = "aws.protocoltests.restjson#HttpRequestWithGreedyLabelInPathInput" +_s190 = "EpochSeconds" +_s191 = "epoch-seconds" +_s192 = "HttpDate" +_s193 = "http-date" +_s194 = "HttpRequestWithLabelsAndTimestampFormatInput" +_s195 = "aws.protocoltests.restjson#HttpRequestWithLabelsAndTimestampFormatInput" +_s196 = "memberEpochSeconds" +_s197 = "smithy.api#httpLabel" +_s198 = "smithy.api#required" +_s199 = "memberHttpDate" +_s200 = "memberDateTime" +_s201 = "defaultFormat" +_s202 = "targetEpochSeconds" +_s203 = "targetHttpDate" +_s204 = "targetDateTime" +_s205 = "HttpRequestWithLabelsInput" +_s206 = "aws.protocoltests.restjson#HttpRequestWithLabelsInput" +_s207 = "string" +_s208 = "short" +_s209 = "integer" +_s210 = "long" +_s211 = "boolean" +_s212 = "timestamp" +_s213 = "HttpRequestWithRegexLiteralInput" +_s214 = "aws.protocoltests.restjson#HttpRequestWithRegexLiteralInput" +_s215 = "str" +_s216 = "HttpResponseCodeOutput" +_s217 = "aws.protocoltests.restjson#HttpResponseCodeOutput" +_s218 = "Status" +_s219 = "IgnoreQueryParamsInResponseOutput" +_s220 = "aws.protocoltests.restjson#IgnoreQueryParamsInResponseOutput" +_s221 = "InvalidGreeting" +_s222 = "Message" +_s223 = "JsonHeaderString" +_s224 = "smithy.api#mediaType" +_s225 = "application/json" +_s226 = "JsonValue" +_s227 = "MalformedAcceptWithGenericStringOutput" +_s228 = "aws.protocoltests.restjson#MalformedAcceptWithGenericStringOutput" +_s229 = "payload" +_s434 = "AllQueryStringTypesOutput" +_s435 = "smithy.api#Unit" +_s436 = "ConstantAndVariableQueryStringOutput" +_s437 = "ConstantQueryStringOutput" +_s438 = "DatetimeOffsetsInput" +_s456 = "FractionalSecondsInput" +_s457 = "GreetingWithErrorsInput" +_s484 = "HttpRequestWithFloatLabelsOutput" +_s485 = "HttpRequestWithGreedyLabelInPathOutput" +_s486 = "HttpRequestWithLabelsOutput" +_s487 = "HttpRequestWithLabelsAndTimestampFormatOutput" +_s488 = "HttpRequestWithRegexLiteralOutput" +_s489 = "HttpResponseCodeInput" +_s493 = "IgnoreQueryParamsInResponseInput" +_s592 = "MalformedAcceptWithGenericStringInput" +_s713 = "AllQueryStringTypes" +_s714 = "smithy.api#http" +_s715 = "ConstantAndVariableQueryString" +_s716 = "ConstantQueryString" +_s717 = "ContentTypeParameters" +_s718 = "DatetimeOffsets" +_s722 = "EmptyInputAndEmptyOutput" +_s726 = "FractionalSeconds" +_s727 = "GreetingWithErrors" +_s731 = "HttpEmptyPrefixHeaders" +_s737 = "HttpPrefixHeaders" +_s738 = "HttpPrefixHeadersInResponse" +_s740 = "HttpRequestWithFloatLabels" +_s741 = "HttpRequestWithGreedyLabelInPath" +_s742 = "HttpRequestWithLabels" +_s743 = "HttpRequestWithLabelsAndTimestampFormat" +_s744 = "HttpRequestWithRegexLiteral" +_s745 = "HttpResponseCode" +_s747 = "IgnoreQueryParamsInResponse" +_s757 = "MalformedAcceptWithGenericString" + +STRING_LIST: StaticSchema = ( + 16, + n0, + _s0, + 0, + (_s1,), + ((3, 0),), +) + +STRING_SET: StaticSchema = ( + 16, + n0, + _s2, + 0, + (_s1,), + ((3, 0),), +) + +INTEGER_LIST: StaticSchema = ( + 16, + n0, + _s3, + 0, + (_s1,), + ((7, 0),), +) + +INTEGER_SET: StaticSchema = ( + 16, + n0, + _s4, + 0, + (_s1,), + ((7, 0),), +) + +DOUBLE_LIST: StaticSchema = ( + 16, + n0, + _s5, + 0, + (_s1,), + ((10, 0),), +) + +BOOLEAN_LIST: StaticSchema = ( + 16, + n0, + _s6, + 0, + (_s1,), + ((2, 0),), +) + +TIMESTAMP_LIST: StaticSchema = ( + 16, + n0, + _s7, + 0, + (_s1,), + ((4, 0),), +) + +FOO_ENUM: StaticSchema = ( + 14, + n0, + _s8, + 0, + (_s9, _s12, _s14, _s16, _s18), + ( + (-1, {_s10: _s11}), + (-1, {_s10: _s13}), + (-1, {_s10: _s15}), + (-1, {_s10: _s17}), + (-1, {_s10: _s19}), + ), +) + +FOO_ENUM_LIST: StaticSchema = ( + 16, + n0, + _s20, + 0, + (_s1,), + ((FOO_ENUM, 0),), +) + +INTEGER_ENUM: StaticSchema = ( + 15, + n0, + _s21, + 0, + (_s22, _s23, _s24), + ((-1, {_s10: 1}), (-1, {_s10: 2}), (-1, {_s10: 3})), +) + +INTEGER_ENUM_LIST: StaticSchema = ( + 16, + n0, + _s25, + 0, + (_s1,), + ((INTEGER_ENUM, 0),), +) + +STRING_LIST_MAP: StaticSchema = ( + 17, + n0, + _s26, + 0, + (_s27, _s28), + ((3, 0), (STRING_LIST, 0)), +) + +ALL_QUERY_STRING_TYPES_INPUT: StaticSchema = ( + 18, + n1, + _s29, + {_s30: _s31, _s32: None}, + ( + _s33, + _s36, + _s37, + _s38, + _s40, + _s42, + _s44, + _s45, + _s46, + _s48, + _s50, + _s52, + _s53, + _s55, + _s56, + _s58, + _s59, + _s61, + _s63, + _s64, + _s65, + ), + ( + (3, {_s34: _s35}), + (STRING_LIST, {_s34: _s0}), + (STRING_SET, {_s34: _s2}), + (5, {_s34: _s39}), + (6, {_s34: _s41}), + (7, {_s34: _s43}), + (INTEGER_LIST, {_s34: _s3}), + (INTEGER_SET, {_s34: _s4}), + (8, {_s34: _s47}), + (9, {_s34: _s49}), + (10, {_s34: _s51}), + (DOUBLE_LIST, {_s34: _s5}), + (2, {_s34: _s54}), + (BOOLEAN_LIST, {_s34: _s6}), + (4, {_s34: _s57}), + (TIMESTAMP_LIST, {_s34: _s7}), + (FOO_ENUM, {_s34: _s60}), + (FOO_ENUM_LIST, {_s34: _s62}), + (INTEGER_ENUM, {_s34: _s21}), + (INTEGER_ENUM_LIST, {_s34: _s25}), + (STRING_LIST_MAP, 1024), + ), +) + +ALL_QUERY_STRING_TYPES_OUTPUT: StaticSchema = ( + 18, + n1, + _s434, + {_s30: _s435, _s92: None}, +) + +ALL_QUERY_STRING_TYPES: StaticOperationSchema = ( + 23, + n1, + _s713, + {_s714: MappingProxyType({"uri": "/AllQueryStringTypesInput", "method": "GET"})}, + ALL_QUERY_STRING_TYPES_INPUT, + ALL_QUERY_STRING_TYPES_OUTPUT, + (), +) + +CLIENT_OPTIONAL_DEFAULTS: StaticSchema = ( + 18, + n1, + _s66, + 0, + (_s1,), + ((7, {_s67: None, _s68: 0}),), +) + +COMPLEX_NESTED_ERROR_DATA: StaticSchema = ( + 18, + n1, + _s69, + 0, + (_s11,), + ((3, {_s70: _s71}),), +) + +COMPLEX_ERROR: StaticSchema = ( + 18, + n1, + _s72, + {_s73: _s74, _s75: 403}, + (_s76, _s79, _s80), + ((3, {_s77: _s78}), (3, 0), (COMPLEX_NESTED_ERROR_DATA, 0)), +) + +CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT: StaticSchema = ( + 18, + n1, + _s81, + {_s30: _s82, _s32: None}, + (_s83, _s84), + ((3, {_s34: _s83}), (3, {_s34: _s84})), +) + +CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _s436, + {_s30: _s435, _s92: None}, +) + +CONSTANT_AND_VARIABLE_QUERY_STRING: StaticOperationSchema = ( + 23, + n1, + _s715, + { + _s714: MappingProxyType( + {"uri": "/ConstantAndVariableQueryString?foo=bar", "method": "GET"} + ) + }, + CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT, + CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT, + (), +) + +CONSTANT_QUERY_STRING_INPUT: StaticSchema = ( + 18, + n1, + _s85, + {_s30: _s86, _s32: None}, + (_s87,), + ((3, 9),), +) + +CONSTANT_QUERY_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _s437, + {_s30: _s435, _s92: None}, +) + +CONSTANT_QUERY_STRING: StaticOperationSchema = ( + 23, + n1, + _s716, + { + _s714: MappingProxyType( + {"uri": "/ConstantQueryString/{hello}?foo=bar&hello", "method": "GET"} + ) + }, + CONSTANT_QUERY_STRING_INPUT, + CONSTANT_QUERY_STRING_OUTPUT, + (), +) + +CONTENT_TYPE_PARAMETERS_INPUT: StaticSchema = ( + 18, + n1, + _s88, + {_s30: _s89, _s32: None}, + (_s28,), + ((7, 0),), +) + +CONTENT_TYPE_PARAMETERS_OUTPUT: StaticSchema = ( + 18, + n1, + _s90, + {_s30: _s91, _s92: None}, +) + +CONTENT_TYPE_PARAMETERS: StaticOperationSchema = ( + 23, + n1, + _s717, + {_s714: MappingProxyType({"uri": "/ContentTypeParameters", "method": "POST"})}, + CONTENT_TYPE_PARAMETERS_INPUT, + CONTENT_TYPE_PARAMETERS_OUTPUT, + (), +) + +DATE_TIME: StaticSchema = ( + 4, + n0, + _s93, + {_s94: _s95}, +) + +DATETIME_OFFSETS_OUTPUT: StaticSchema = ( + 18, + n1, + _s96, + {_s30: _s97, _s92: None}, + (_s98,), + ((DATE_TIME, 0),), +) + +DATETIME_OFFSETS_INPUT: StaticSchema = ( + 18, + n1, + _s438, + {_s30: _s435, _s32: None}, +) + +DATETIME_OFFSETS: StaticOperationSchema = ( + 23, + n1, + _s718, + {_s714: MappingProxyType({"uri": "/DatetimeOffsets", "method": "POST"})}, + DATETIME_OFFSETS_INPUT, + DATETIME_OFFSETS_OUTPUT, + (), +) + +TEST_STRING_LIST: StaticSchema = ( + 16, + n1, + _s99, + 0, + (_s1,), + ((3, 0),), +) + +TEST_STRING_MAP: StaticSchema = ( + 17, + n1, + _s101, + 0, + (_s27, _s28), + ((3, 0), (3, 0)), +) + +TEST_ENUM: StaticSchema = ( + 14, + n1, + _s102, + 0, + (_s9, _s14, _s12), + ((-1, {_s10: _s9}), (-1, {_s10: _s14}), (-1, {_s10: _s12})), +) + +TEST_INT_ENUM: StaticSchema = ( + 15, + n1, + _s103, + 0, + (_s16, _s104), + ((-1, {_s10: 1}), (-1, {_s10: 2})), +) + +DEFAULTS: StaticSchema = ( + 18, + n1, + _s105, + 0, + ( + _s106, + _s108, + _s109, + _s110, + _s111, + _s112, + _s113, + _s114, + _s115, + _s116, + _s118, + _s119, + _s120, + _s121, + _s122, + _s123, + _s124, + _s125, + _s126, + _s127, + _s129, + _s130, + _s131, + _s132, + _s133, + _s134, + _s135, + _s136, + ), + ( + (3, {_s68: _s107}), + (2, {_s68: True}), + (TEST_STRING_LIST, {_s68: ()}), + (lambda: schemas.DOCUMENT, {_s68: MappingProxyType[str, object]({})}), + (lambda: schemas.DOCUMENT, {_s68: _s107}), + (lambda: schemas.DOCUMENT, {_s68: True}), + (lambda: schemas.DOCUMENT, {_s68: ()}), + (lambda: schemas.DOCUMENT, {_s68: None}), + (4, {_s68: 0}), + (1, {_s68: _s117}), + (5, {_s68: 1}), + (6, {_s68: 1}), + (7, {_s68: 10}), + (8, {_s68: 100}), + (9, {_s68: 1.0}), + (10, {_s68: 1.0}), + (TEST_STRING_MAP, {_s68: MappingProxyType[str, object]({})}), + (TEST_ENUM, {_s68: _s9}), + (TEST_INT_ENUM, {_s68: 1}), + (3, {_s68: _s128}), + (2, {_s68: False}), + (1, {_s68: _s128}), + (5, {_s68: 0}), + (6, {_s68: 0}), + (7, {_s68: 0}), + (8, {_s68: 0}), + (9, {_s68: 0.0}), + (10, {_s68: 0.0}), + ), +) + +DENSE_BOOLEAN_MAP: StaticSchema = ( + 17, + n1, + _s137, + 0, + (_s27, _s28), + ((3, 0), (2, 0)), +) + +DENSE_NUMBER_MAP: StaticSchema = ( + 17, + n1, + _s138, + 0, + (_s27, _s28), + ((3, 0), (7, 0)), +) + +DENSE_SET_MAP: StaticSchema = ( + 17, + n1, + _s139, + 0, + (_s27, _s28), + ((3, 0), (STRING_SET, 0)), +) + +DENSE_STRING_MAP: StaticSchema = ( + 17, + n1, + _s140, + 0, + (_s27, _s28), + ((3, 0), (3, 0)), +) + +GREETING_STRUCT: StaticSchema = ( + 18, + n0, + _s141, + 0, + (_s107,), + ((3, 0),), +) + +DENSE_STRUCT_MAP: StaticSchema = ( + 17, + n1, + _s142, + 0, + (_s27, _s28), + ((3, 0), (GREETING_STRUCT, 0)), +) + +FAREWELL: StaticSchema = ( + 18, + n1, + _s143, + 0, + (_s144,), + ((3, {_s68: _s145}),), +) + +DIALOG: StaticSchema = ( + 18, + n1, + _s146, + 0, + (_s147, _s148, _s149), + ((3, 0), (3, {_s68: _s107}), (FAREWELL, 0)), +) + +DIALOG_LIST: StaticSchema = ( + 16, + n1, + _s150, + 0, + (_s1,), + ((DIALOG, 0),), +) + +DIALOG_MAP: StaticSchema = ( + 17, + n1, + _s151, + 0, + (_s27, _s28), + ((3, 0), (DIALOG, 0)), +) + +DOCUMENT_VALUED_MAP: StaticSchema = ( + 17, + n1, + _s152, + 0, + (_s27, _s28), + ((3, 0), (lambda: schemas.DOCUMENT, 0)), +) + +EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT: StaticSchema = ( + 18, + n1, + _s153, + {_s30: _s154, _s32: None}, +) + +EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT: StaticSchema = ( + 18, + n1, + _s155, + {_s30: _s156, _s92: None}, +) + +EMPTY_INPUT_AND_EMPTY_OUTPUT: StaticOperationSchema = ( + 23, + n1, + _s722, + {_s714: MappingProxyType({"uri": "/EmptyInputAndEmptyOutput", "method": "POST"})}, + EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT, + EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT, + (), +) + +FOO_ERROR: StaticSchema = ( + 18, + n1, + _s157, + {_s73: _s158, _s75: 500}, +) + +FRACTIONAL_SECONDS_OUTPUT: StaticSchema = ( + 18, + n1, + _s159, + {_s30: _s160, _s92: None}, + (_s98,), + ((DATE_TIME, 0),), +) + +FRACTIONAL_SECONDS_INPUT: StaticSchema = ( + 18, + n1, + _s456, + {_s30: _s435, _s32: None}, +) + +FRACTIONAL_SECONDS: StaticOperationSchema = ( + 23, + n1, + _s726, + {_s714: MappingProxyType({"uri": "/FractionalSeconds", "method": "POST"})}, + FRACTIONAL_SECONDS_INPUT, + FRACTIONAL_SECONDS_OUTPUT, + (), +) + +GREETING_WITH_ERRORS_OUTPUT: StaticSchema = ( + 18, + n1, + _s161, + {_s30: _s162, _s92: None}, + (_s148,), + ((3, {_s77: _s163}),), +) + +GREETING_WITH_ERRORS_INPUT: StaticSchema = ( + 18, + n1, + _s457, + {_s30: _s435, _s32: None}, +) + +GREETING_WITH_ERRORS: StaticOperationSchema = ( + 23, + n1, + _s727, + {_s714: MappingProxyType({"uri": "/GreetingWithErrors", "method": "PUT"})}, + GREETING_WITH_ERRORS_INPUT, + GREETING_WITH_ERRORS_OUTPUT, + (COMPLEX_ERROR, FOO_ERROR, lambda: INVALID_GREETING), +) + +STRING_MAP: StaticSchema = ( + 17, + n0, + _s164, + 0, + (_s27, _s28), + ((3, 0), (3, 0)), +) + +HTTP_EMPTY_PREFIX_HEADERS_INPUT: StaticSchema = ( + 18, + n1, + _s165, + {_s30: _s166, _s32: None}, + (_s167, _s169), + ((STRING_MAP, {_s168: _s128}), (3, {_s77: _s87})), +) + +HTTP_EMPTY_PREFIX_HEADERS_OUTPUT: StaticSchema = ( + 18, + n1, + _s170, + {_s30: _s171, _s92: None}, + (_s167, _s169), + ((STRING_MAP, {_s168: _s128}), (3, {_s77: _s87})), +) + +HTTP_EMPTY_PREFIX_HEADERS: StaticOperationSchema = ( + 23, + n1, + _s731, + {_s714: MappingProxyType({"uri": "/HttpEmptyPrefixHeaders", "method": "GET"})}, + HTTP_EMPTY_PREFIX_HEADERS_INPUT, + HTTP_EMPTY_PREFIX_HEADERS_OUTPUT, + (), +) + +HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT: StaticSchema = ( + 18, + n1, + _s172, + {_s30: _s173, _s32: None}, +) + +HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT: StaticSchema = ( + 18, + n1, + _s174, + {_s30: _s175, _s92: None}, + (_s167,), + ((STRING_MAP, {_s168: _s128}),), +) + +HTTP_PREFIX_HEADERS_IN_RESPONSE: StaticOperationSchema = ( + 23, + n1, + _s738, + {_s714: MappingProxyType({"uri": "/HttpPrefixHeadersResponse", "method": "GET"})}, + HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT, + HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT, + (), +) + +HTTP_PREFIX_HEADERS_INPUT: StaticSchema = ( + 18, + n1, + _s176, + {_s30: _s177, _s32: None}, + (_s178, _s180), + ((3, {_s77: _s179}), (STRING_MAP, {_s168: _s181})), +) + +HTTP_PREFIX_HEADERS_OUTPUT: StaticSchema = ( + 18, + n1, + _s182, + {_s30: _s183, _s92: None}, + (_s178, _s180), + ((3, {_s77: _s179}), (STRING_MAP, {_s168: _s181})), +) + +HTTP_PREFIX_HEADERS: StaticOperationSchema = ( + 23, + n1, + _s737, + {_s714: MappingProxyType({"uri": "/HttpPrefixHeaders", "method": "GET"})}, + HTTP_PREFIX_HEADERS_INPUT, + HTTP_PREFIX_HEADERS_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT: StaticSchema = ( + 18, + n1, + _s184, + {_s30: _s185, _s32: None}, + (_s186, _s187), + ((9, 9), (10, 9)), +) + +HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT: StaticSchema = ( + 18, + n1, + _s484, + {_s30: _s435, _s92: None}, +) + +HTTP_REQUEST_WITH_FLOAT_LABELS: StaticOperationSchema = ( + 23, + n1, + _s740, + { + _s714: MappingProxyType( + {"method": "GET", "uri": "/FloatHttpLabels/{float}/{double}"} + ) + }, + HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT, + HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT: StaticSchema = ( + 18, + n1, + _s188, + {_s30: _s189, _s32: None}, + (_s178, _s83), + ((3, 9), (3, 9)), +) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT: StaticSchema = ( + 18, + n1, + _s485, + {_s30: _s435, _s92: None}, +) + +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH: StaticOperationSchema = ( + 23, + n1, + _s741, + { + _s714: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithGreedyLabelInPath/foo/{foo}/baz/{baz+}", + } + ) + }, + HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT, + HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT, + (), +) + +EPOCH_SECONDS: StaticSchema = ( + 4, + n0, + _s190, + {_s94: _s191}, +) + +HTTP_DATE: StaticSchema = ( + 4, + n0, + _s192, + {_s94: _s193}, +) + +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT: StaticSchema = ( + 18, + n1, + _s194, + {_s30: _s195, _s32: None}, + (_s196, _s199, _s200, _s201, _s202, _s203, _s204), + ( + (4, {_s94: _s191, _s197: None, _s198: None}), + (4, {_s94: _s193, _s197: None, _s198: None}), + (4, {_s94: _s95, _s197: None, _s198: None}), + (4, 9), + (EPOCH_SECONDS, 9), + (HTTP_DATE, 9), + (DATE_TIME, 9), + ), +) + +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT: StaticSchema = ( + 18, + n1, + _s487, + {_s30: _s435, _s92: None}, +) + +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT: StaticOperationSchema = ( + 23, + n1, + _s743, + { + _s714: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithLabelsAndTimestampFormat/{memberEpochSeconds}/{memberHttpDate}/{memberDateTime}/{defaultFormat}/{targetEpochSeconds}/{targetHttpDate}/{targetDateTime}", + } + ) + }, + HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT, + HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_LABELS_INPUT: StaticSchema = ( + 18, + n1, + _s205, + {_s30: _s206, _s32: None}, + (_s207, _s208, _s209, _s210, _s186, _s187, _s211, _s212), + ((3, 9), (6, 9), (7, 9), (8, 9), (9, 9), (10, 9), (2, 9), (4, 9)), +) + +HTTP_REQUEST_WITH_LABELS_OUTPUT: StaticSchema = ( + 18, + n1, + _s486, + {_s30: _s435, _s92: None}, +) + +HTTP_REQUEST_WITH_LABELS: StaticOperationSchema = ( + 23, + n1, + _s742, + { + _s714: MappingProxyType( + { + "method": "GET", + "uri": "/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}", + } + ) + }, + HTTP_REQUEST_WITH_LABELS_INPUT, + HTTP_REQUEST_WITH_LABELS_OUTPUT, + (), +) + +HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT: StaticSchema = ( + 18, + n1, + _s213, + {_s30: _s214, _s32: None}, + (_s215,), + ((3, 9),), +) + +HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT: StaticSchema = ( + 18, + n1, + _s488, + {_s30: _s435, _s92: None}, +) + +HTTP_REQUEST_WITH_REGEX_LITERAL: StaticOperationSchema = ( + 23, + n1, + _s744, + {_s714: MappingProxyType({"method": "GET", "uri": "/ReDosLiteral/{str}/(a+)+"})}, + HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT, + HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT, + (), +) + +HTTP_RESPONSE_CODE_OUTPUT: StaticSchema = ( + 18, + n1, + _s216, + {_s30: _s217, _s92: None}, + (_s218,), + ((7, 128),), +) + +HTTP_RESPONSE_CODE_INPUT: StaticSchema = ( + 18, + n1, + _s489, + {_s30: _s435, _s32: None}, +) + +HTTP_RESPONSE_CODE: StaticOperationSchema = ( + 23, + n1, + _s745, + {_s714: MappingProxyType({"uri": "/HttpResponseCode", "method": "PUT"})}, + HTTP_RESPONSE_CODE_INPUT, + HTTP_RESPONSE_CODE_OUTPUT, + (), +) + +IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT: StaticSchema = ( + 18, + n1, + _s219, + {_s30: _s220, _s92: None}, + (_s83,), + ((3, {_s34: _s83}),), +) + +IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT: StaticSchema = ( + 18, + n1, + _s493, + {_s30: _s435, _s32: None}, +) + +IGNORE_QUERY_PARAMS_IN_RESPONSE: StaticOperationSchema = ( + 23, + n1, + _s747, + {_s714: MappingProxyType({"uri": "/IgnoreQueryParamsInResponse", "method": "GET"})}, + IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT, + IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT, + (), +) + +INVALID_GREETING: StaticSchema = ( + 18, + n1, + _s221, + {_s73: _s74, _s75: 400}, + (_s222,), + ((3, 0),), +) + +JSON_HEADER_STRING: StaticSchema = ( + 3, + n1, + _s223, + {_s224: _s225}, +) + +JSON_VALUE: StaticSchema = ( + 3, + n1, + _s226, + {_s224: _s225}, +) + +MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _s227, + {_s30: _s228, _s92: None}, + (_s229,), + ((3, 16),), +) + +MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT: StaticSchema = ( + 18, + n1, + _s592, + {_s30: _s435, _s32: None}, +) + +MALFORMED_ACCEPT_WITH_GENERIC_STRING: StaticOperationSchema = ( + 23, + n1, + _s757, + { + _s714: MappingProxyType( + {"method": "POST", "uri": "/MalformedAcceptWithGenericString"} + ) + }, + MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT, + MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT, + (), +) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_1.py b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_1.py new file mode 100644 index 000000000..4c85aeab5 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_1.py @@ -0,0 +1,1221 @@ +from types import MappingProxyType + +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + +from . import schemas + +n0 = "aws.protocoltests.shared" +_s1 = "member" +_s27 = "key" +_s28 = "value" +n1 = "aws.protocoltests.restjson" +_s30 = "smithy.synthetic#originalShapeId" +_s32 = "smithy.api#input" +_s34 = "smithy.api#httpQuery" +_s77 = "smithy.api#httpHeader" +_s92 = "smithy.api#output" +_s94 = "smithy.api#timestampFormat" +_s95 = "date-time" +_s127 = "emptyString" +_s141 = "GreetingStruct" +_s148 = "greeting" +_s186 = "float" +_s191 = "epoch-seconds" +_s193 = "http-date" +_s197 = "smithy.api#httpLabel" +_s198 = "smithy.api#required" +_s207 = "string" +_s212 = "timestamp" +_s224 = "smithy.api#mediaType" +_s229 = "payload" +_s230 = "JpegBlob" +_s231 = "image/jpeg" +_s232 = "MalformedAcceptWithPayloadOutput" +_s233 = "aws.protocoltests.restjson#MalformedAcceptWithPayloadOutput" +_s234 = "MalformedBlobInput" +_s235 = "aws.protocoltests.restjson#MalformedBlobInput" +_s236 = "blob" +_s237 = "MalformedBooleanInput" +_s238 = "aws.protocoltests.restjson#MalformedBooleanInput" +_s239 = "booleanInBody" +_s240 = "booleanInPath" +_s241 = "booleanInQuery" +_s242 = "booleanInHeader" +_s243 = "MalformedByteInput" +_s244 = "aws.protocoltests.restjson#MalformedByteInput" +_s245 = "byteInBody" +_s246 = "byteInPath" +_s247 = "byteInQuery" +_s248 = "byteInHeader" +_s249 = "MalformedContentTypeWithGenericStringInput" +_s250 = "aws.protocoltests.restjson#MalformedContentTypeWithGenericStringInput" +_s251 = "MalformedContentTypeWithPayloadInput" +_s252 = "aws.protocoltests.restjson#MalformedContentTypeWithPayloadInput" +_s253 = "MalformedContentTypeWithoutBodyEmptyInputInput" +_s254 = "aws.protocoltests.restjson#MalformedContentTypeWithoutBodyEmptyInputInput" +_s255 = "header" +_s256 = "MalformedDoubleInput" +_s257 = "aws.protocoltests.restjson#MalformedDoubleInput" +_s258 = "doubleInBody" +_s259 = "doubleInPath" +_s260 = "doubleInQuery" +_s261 = "doubleInHeader" +_s262 = "MalformedFloatInput" +_s263 = "aws.protocoltests.restjson#MalformedFloatInput" +_s264 = "floatInBody" +_s265 = "floatInPath" +_s266 = "floatInQuery" +_s267 = "floatInHeader" +_s268 = "MalformedIntegerInput" +_s269 = "aws.protocoltests.restjson#MalformedIntegerInput" +_s270 = "integerInBody" +_s271 = "integerInPath" +_s272 = "integerInQuery" +_s273 = "integerInHeader" +_s274 = "SimpleList" +_s275 = "MalformedListInput" +_s276 = "aws.protocoltests.restjson#MalformedListInput" +_s277 = "bodyList" +_s278 = "MalformedLongInput" +_s279 = "aws.protocoltests.restjson#MalformedLongInput" +_s280 = "longInBody" +_s281 = "longInPath" +_s282 = "longInQuery" +_s283 = "longInHeader" +_s284 = "SimpleMap" +_s285 = "MalformedMapInput" +_s286 = "aws.protocoltests.restjson#MalformedMapInput" +_s287 = "bodyMap" +_s288 = "MalformedRequestBodyInput" +_s289 = "aws.protocoltests.restjson#MalformedRequestBodyInput" +_s290 = "int" +_s291 = "MalformedShortInput" +_s292 = "aws.protocoltests.restjson#MalformedShortInput" +_s293 = "shortInBody" +_s294 = "shortInPath" +_s295 = "shortInQuery" +_s296 = "shortInHeader" +_s297 = "MalformedStringInput" +_s298 = "aws.protocoltests.restjson#MalformedStringInput" +_s299 = "amz-media-typed-header" +_s300 = "MalformedTimestampBodyDateTimeInput" +_s301 = "aws.protocoltests.restjson#MalformedTimestampBodyDateTimeInput" +_s302 = "MalformedTimestampBodyDefaultInput" +_s303 = "aws.protocoltests.restjson#MalformedTimestampBodyDefaultInput" +_s304 = "MalformedTimestampBodyHttpDateInput" +_s305 = "aws.protocoltests.restjson#MalformedTimestampBodyHttpDateInput" +_s306 = "MalformedTimestampHeaderDateTimeInput" +_s307 = "aws.protocoltests.restjson#MalformedTimestampHeaderDateTimeInput" +_s308 = "MalformedTimestampHeaderDefaultInput" +_s309 = "aws.protocoltests.restjson#MalformedTimestampHeaderDefaultInput" +_s310 = "MalformedTimestampHeaderEpochInput" +_s311 = "aws.protocoltests.restjson#MalformedTimestampHeaderEpochInput" +_s312 = "MalformedTimestampPathDefaultInput" +_s313 = "aws.protocoltests.restjson#MalformedTimestampPathDefaultInput" +_s314 = "MalformedTimestampPathEpochInput" +_s315 = "aws.protocoltests.restjson#MalformedTimestampPathEpochInput" +_s316 = "MalformedTimestampPathHttpDateInput" +_s317 = "aws.protocoltests.restjson#MalformedTimestampPathHttpDateInput" +_s318 = "MalformedTimestampQueryDefaultInput" +_s319 = "aws.protocoltests.restjson#MalformedTimestampQueryDefaultInput" +_s320 = "MalformedTimestampQueryEpochInput" +_s321 = "aws.protocoltests.restjson#MalformedTimestampQueryEpochInput" +_s322 = "MalformedTimestampQueryHttpDateInput" +_s323 = "aws.protocoltests.restjson#MalformedTimestampQueryHttpDateInput" +_s324 = "SimpleUnion" +_s325 = "MalformedUnionInput" +_s326 = "aws.protocoltests.restjson#MalformedUnionInput" +_s327 = "union" +_s328 = "MediaTypeHeaderInput" +_s329 = "aws.protocoltests.restjson#MediaTypeHeaderInput" +_s330 = "json" +_s331 = "X-Json" +_s332 = "MediaTypeHeaderOutput" +_s333 = "aws.protocoltests.restjson#MediaTypeHeaderOutput" +n2 = "aws.protocoltests.restjson.nested" +_s334 = "salutation" +_s335 = "NestedUnion" +_s336 = "stringValue" +_s337 = "MyUnion" +_s338 = "booleanValue" +_s339 = "numberValue" +_s340 = "blobValue" +_s341 = "timestampValue" +_s342 = "enumValue" +_s343 = "listValue" +_s344 = "mapValue" +_s345 = "structureValue" +_s346 = "renamedStructureValue" +_s347 = "unionValue" +_s348 = "NestedPayload" +_s349 = "name" +_s350 = "NoInputAndOutputOutput" +_s351 = "aws.protocoltests.restjson#NoInputAndOutputOutput" +_s352 = "OmitsNullSerializesEmptyStringInput" +_s353 = "aws.protocoltests.restjson#OmitsNullSerializesEmptyStringInput" +_s354 = "nullValue" +_s355 = "Null" +_s356 = "Empty" +_s435 = "smithy.api#Unit" +_s593 = "MalformedAcceptWithPayloadInput" +_s594 = "MalformedBlobOutput" +_s595 = "MalformedBooleanOutput" +_s596 = "MalformedByteOutput" +_s599 = "MalformedContentTypeWithGenericStringOutput" +_s600 = "MalformedContentTypeWithPayloadOutput" +_s603 = "MalformedContentTypeWithoutBodyEmptyInputOutput" +_s604 = "MalformedDoubleOutput" +_s605 = "MalformedFloatOutput" +_s606 = "MalformedIntegerOutput" +_s607 = "MalformedListOutput" +_s608 = "MalformedLongOutput" +_s609 = "MalformedMapOutput" +_s610 = "MalformedRequestBodyOutput" +_s611 = "MalformedShortOutput" +_s612 = "MalformedStringOutput" +_s613 = "MalformedTimestampBodyDateTimeOutput" +_s614 = "MalformedTimestampBodyDefaultOutput" +_s615 = "MalformedTimestampBodyHttpDateOutput" +_s616 = "MalformedTimestampHeaderDateTimeOutput" +_s617 = "MalformedTimestampHeaderDefaultOutput" +_s618 = "MalformedTimestampHeaderEpochOutput" +_s619 = "MalformedTimestampPathDefaultOutput" +_s620 = "MalformedTimestampPathEpochOutput" +_s621 = "MalformedTimestampPathHttpDateOutput" +_s622 = "MalformedTimestampQueryDefaultOutput" +_s623 = "MalformedTimestampQueryEpochOutput" +_s624 = "MalformedTimestampQueryHttpDateOutput" +_s625 = "MalformedUnionOutput" +_s628 = "NoInputAndOutputInput" +_s638 = "OmitsNullSerializesEmptyStringOutput" +_s714 = "smithy.api#http" +_s758 = "MalformedAcceptWithPayload" +_s759 = "MalformedBlob" +_s760 = "MalformedBoolean" +_s761 = "MalformedByte" +_s763 = "MalformedContentTypeWithGenericString" +_s764 = "MalformedContentTypeWithPayload" +_s766 = "MalformedContentTypeWithoutBodyEmptyInput" +_s767 = "MalformedDouble" +_s768 = "MalformedFloat" +_s769 = "MalformedInteger" +_s770 = "MalformedList" +_s771 = "MalformedLong" +_s772 = "MalformedMap" +_s773 = "MalformedRequestBody" +_s774 = "MalformedShort" +_s775 = "MalformedString" +_s776 = "MalformedTimestampBodyDateTime" +_s777 = "MalformedTimestampBodyDefault" +_s778 = "MalformedTimestampBodyHttpDate" +_s779 = "MalformedTimestampHeaderDateTime" +_s780 = "MalformedTimestampHeaderDefault" +_s781 = "MalformedTimestampHeaderEpoch" +_s782 = "MalformedTimestampPathDefault" +_s783 = "MalformedTimestampPathEpoch" +_s784 = "MalformedTimestampPathHttpDate" +_s785 = "MalformedTimestampQueryDefault" +_s786 = "MalformedTimestampQueryEpoch" +_s787 = "MalformedTimestampQueryHttpDate" +_s788 = "MalformedUnion" +_s789 = "MediaTypeHeader" +_s791 = "NoInputAndOutput" +_s794 = "OmitsNullSerializesEmptyString" + +JPEG_BLOB: StaticSchema = ( + 1, + n0, + _s230, + {_s224: _s231}, +) + +MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s232, + {_s30: _s233, _s92: None}, + (_s229,), + ((JPEG_BLOB, 16),), +) + +MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s593, + {_s30: _s435, _s32: None}, +) + +MALFORMED_ACCEPT_WITH_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s758, + {_s714: MappingProxyType({"method": "POST", "uri": "/MalformedAcceptWithPayload"})}, + MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT, + MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT, + (), +) + +MALFORMED_BLOB_INPUT: StaticSchema = ( + 18, + n1, + _s234, + {_s30: _s235, _s32: None}, + (_s236,), + ((1, 0),), +) + +MALFORMED_BLOB_OUTPUT: StaticSchema = ( + 18, + n1, + _s594, + {_s30: _s435, _s92: None}, +) + +MALFORMED_BLOB: StaticOperationSchema = ( + 23, + n1, + _s759, + {_s714: MappingProxyType({"uri": "/MalformedBlob", "method": "POST"})}, + MALFORMED_BLOB_INPUT, + MALFORMED_BLOB_OUTPUT, + (), +) + +MALFORMED_BOOLEAN_INPUT: StaticSchema = ( + 18, + n1, + _s237, + {_s30: _s238, _s32: None}, + (_s239, _s240, _s241, _s242), + ((2, 0), (2, 9), (2, {_s34: _s241}), (2, {_s77: _s242})), +) + +MALFORMED_BOOLEAN_OUTPUT: StaticSchema = ( + 18, + n1, + _s595, + {_s30: _s435, _s92: None}, +) + +MALFORMED_BOOLEAN: StaticOperationSchema = ( + 23, + n1, + _s760, + { + _s714: MappingProxyType( + {"uri": "/MalformedBoolean/{booleanInPath}", "method": "POST"} + ) + }, + MALFORMED_BOOLEAN_INPUT, + MALFORMED_BOOLEAN_OUTPUT, + (), +) + +MALFORMED_BYTE_INPUT: StaticSchema = ( + 18, + n1, + _s243, + {_s30: _s244, _s32: None}, + (_s245, _s246, _s247, _s248), + ((5, 0), (5, 9), (5, {_s34: _s247}), (5, {_s77: _s248})), +) + +MALFORMED_BYTE_OUTPUT: StaticSchema = ( + 18, + n1, + _s596, + {_s30: _s435, _s92: None}, +) + +MALFORMED_BYTE: StaticOperationSchema = ( + 23, + n1, + _s761, + {_s714: MappingProxyType({"uri": "/MalformedByte/{byteInPath}", "method": "POST"})}, + MALFORMED_BYTE_INPUT, + MALFORMED_BYTE_OUTPUT, + (), +) + +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT: StaticSchema = ( + 18, + n1, + _s249, + {_s30: _s250, _s32: None}, + (_s229,), + ((3, 16),), +) + +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _s599, + {_s30: _s435, _s92: None}, +) + +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING: StaticOperationSchema = ( + 23, + n1, + _s763, + { + _s714: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithGenericString"} + ) + }, + MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT, + MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT, + (), +) + +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s251, + {_s30: _s252, _s32: None}, + (_s229,), + ((JPEG_BLOB, 16),), +) + +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s600, + {_s30: _s435, _s92: None}, +) + +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s764, + { + _s714: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithPayload"} + ) + }, + MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT, + MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT, + (), +) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT: StaticSchema = ( + 18, + n1, + _s253, + {_s30: _s254, _s32: None}, + (_s255,), + ((3, {_s77: _s255}),), +) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT: StaticSchema = ( + 18, + n1, + _s603, + {_s30: _s435, _s92: None}, +) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT: StaticOperationSchema = ( + 23, + n1, + _s766, + { + _s714: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithoutBodyEmptyInput"} + ) + }, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT, + (), +) + +MALFORMED_DOUBLE_INPUT: StaticSchema = ( + 18, + n1, + _s256, + {_s30: _s257, _s32: None}, + (_s258, _s259, _s260, _s261), + ((10, 0), (10, 9), (10, {_s34: _s260}), (10, {_s77: _s261})), +) + +MALFORMED_DOUBLE_OUTPUT: StaticSchema = ( + 18, + n1, + _s604, + {_s30: _s435, _s92: None}, +) + +MALFORMED_DOUBLE: StaticOperationSchema = ( + 23, + n1, + _s767, + { + _s714: MappingProxyType( + {"uri": "/MalformedDouble/{doubleInPath}", "method": "POST"} + ) + }, + MALFORMED_DOUBLE_INPUT, + MALFORMED_DOUBLE_OUTPUT, + (), +) + +MALFORMED_FLOAT_INPUT: StaticSchema = ( + 18, + n1, + _s262, + {_s30: _s263, _s32: None}, + (_s264, _s265, _s266, _s267), + ((9, 0), (9, 9), (9, {_s34: _s266}), (9, {_s77: _s267})), +) + +MALFORMED_FLOAT_OUTPUT: StaticSchema = ( + 18, + n1, + _s605, + {_s30: _s435, _s92: None}, +) + +MALFORMED_FLOAT: StaticOperationSchema = ( + 23, + n1, + _s768, + { + _s714: MappingProxyType( + {"uri": "/MalformedFloat/{floatInPath}", "method": "POST"} + ) + }, + MALFORMED_FLOAT_INPUT, + MALFORMED_FLOAT_OUTPUT, + (), +) + +MALFORMED_INTEGER_INPUT: StaticSchema = ( + 18, + n1, + _s268, + {_s30: _s269, _s32: None}, + (_s270, _s271, _s272, _s273), + ((7, 0), (7, 9), (7, {_s34: _s272}), (7, {_s77: _s273})), +) + +MALFORMED_INTEGER_OUTPUT: StaticSchema = ( + 18, + n1, + _s606, + {_s30: _s435, _s92: None}, +) + +MALFORMED_INTEGER: StaticOperationSchema = ( + 23, + n1, + _s769, + { + _s714: MappingProxyType( + {"uri": "/MalformedInteger/{integerInPath}", "method": "POST"} + ) + }, + MALFORMED_INTEGER_INPUT, + MALFORMED_INTEGER_OUTPUT, + (), +) + +SIMPLE_LIST: StaticSchema = ( + 16, + n1, + _s274, + 0, + (_s1,), + ((3, 0),), +) + +MALFORMED_LIST_INPUT: StaticSchema = ( + 18, + n1, + _s275, + {_s30: _s276, _s32: None}, + (_s277,), + ((SIMPLE_LIST, 0),), +) + +MALFORMED_LIST_OUTPUT: StaticSchema = ( + 18, + n1, + _s607, + {_s30: _s435, _s92: None}, +) + +MALFORMED_LIST: StaticOperationSchema = ( + 23, + n1, + _s770, + {_s714: MappingProxyType({"uri": "/MalformedList", "method": "POST"})}, + MALFORMED_LIST_INPUT, + MALFORMED_LIST_OUTPUT, + (), +) + +MALFORMED_LONG_INPUT: StaticSchema = ( + 18, + n1, + _s278, + {_s30: _s279, _s32: None}, + (_s280, _s281, _s282, _s283), + ((8, 0), (8, 9), (8, {_s34: _s282}), (8, {_s77: _s283})), +) + +MALFORMED_LONG_OUTPUT: StaticSchema = ( + 18, + n1, + _s608, + {_s30: _s435, _s92: None}, +) + +MALFORMED_LONG: StaticOperationSchema = ( + 23, + n1, + _s771, + {_s714: MappingProxyType({"uri": "/MalformedLong/{longInPath}", "method": "POST"})}, + MALFORMED_LONG_INPUT, + MALFORMED_LONG_OUTPUT, + (), +) + +SIMPLE_MAP: StaticSchema = ( + 17, + n1, + _s284, + 0, + (_s27, _s28), + ((3, 0), (3, 0)), +) + +MALFORMED_MAP_INPUT: StaticSchema = ( + 18, + n1, + _s285, + {_s30: _s286, _s32: None}, + (_s287,), + ((SIMPLE_MAP, 0),), +) + +MALFORMED_MAP_OUTPUT: StaticSchema = ( + 18, + n1, + _s609, + {_s30: _s435, _s92: None}, +) + +MALFORMED_MAP: StaticOperationSchema = ( + 23, + n1, + _s772, + {_s714: MappingProxyType({"uri": "/MalformedMap", "method": "POST"})}, + MALFORMED_MAP_INPUT, + MALFORMED_MAP_OUTPUT, + (), +) + +MALFORMED_REQUEST_BODY_INPUT: StaticSchema = ( + 18, + n1, + _s288, + {_s30: _s289, _s32: None}, + (_s290, _s186), + ((7, 0), (9, 0)), +) + +MALFORMED_REQUEST_BODY_OUTPUT: StaticSchema = ( + 18, + n1, + _s610, + {_s30: _s435, _s92: None}, +) + +MALFORMED_REQUEST_BODY: StaticOperationSchema = ( + 23, + n1, + _s773, + {_s714: MappingProxyType({"uri": "/MalformedRequestBody", "method": "POST"})}, + MALFORMED_REQUEST_BODY_INPUT, + MALFORMED_REQUEST_BODY_OUTPUT, + (), +) + +MALFORMED_SHORT_INPUT: StaticSchema = ( + 18, + n1, + _s291, + {_s30: _s292, _s32: None}, + (_s293, _s294, _s295, _s296), + ((6, 0), (6, 9), (6, {_s34: _s295}), (6, {_s77: _s296})), +) + +MALFORMED_SHORT_OUTPUT: StaticSchema = ( + 18, + n1, + _s611, + {_s30: _s435, _s92: None}, +) + +MALFORMED_SHORT: StaticOperationSchema = ( + 23, + n1, + _s774, + { + _s714: MappingProxyType( + {"uri": "/MalformedShort/{shortInPath}", "method": "POST"} + ) + }, + MALFORMED_SHORT_INPUT, + MALFORMED_SHORT_OUTPUT, + (), +) + +MALFORMED_STRING_INPUT: StaticSchema = ( + 18, + n1, + _s297, + {_s30: _s298, _s32: None}, + (_s236,), + ((lambda: schemas.JSON_HEADER_STRING, {_s77: _s299}),), +) + +MALFORMED_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _s612, + {_s30: _s435, _s92: None}, +) + +MALFORMED_STRING: StaticOperationSchema = ( + 23, + n1, + _s775, + {_s714: MappingProxyType({"uri": "/MalformedString", "method": "POST"})}, + MALFORMED_STRING_INPUT, + MALFORMED_STRING_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT: StaticSchema = ( + 18, + n1, + _s300, + {_s30: _s301, _s32: None}, + (_s212,), + ((4, {_s94: _s95, _s198: None}),), +) + +MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT: StaticSchema = ( + 18, + n1, + _s613, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_BODY_DATE_TIME: StaticOperationSchema = ( + 23, + n1, + _s776, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampBodyDateTime", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT, + MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT: StaticSchema = ( + 18, + n1, + _s302, + {_s30: _s303, _s32: None}, + (_s212,), + ((4, 1),), +) + +MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT: StaticSchema = ( + 18, + n1, + _s614, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_BODY_DEFAULT: StaticOperationSchema = ( + 23, + n1, + _s777, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampBodyDefault", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT: StaticSchema = ( + 18, + n1, + _s304, + {_s30: _s305, _s32: None}, + (_s212,), + ((4, {_s94: _s193, _s198: None}),), +) + +MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT: StaticSchema = ( + 18, + n1, + _s615, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_BODY_HTTP_DATE: StaticOperationSchema = ( + 23, + n1, + _s778, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampBodyHttpDate", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT, + MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT: StaticSchema = ( + 18, + n1, + _s306, + {_s30: _s307, _s32: None}, + (_s212,), + ((4, {_s77: _s212, _s94: _s95, _s198: None}),), +) + +MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT: StaticSchema = ( + 18, + n1, + _s616, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_HEADER_DATE_TIME: StaticOperationSchema = ( + 23, + n1, + _s779, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampHeaderDateTime", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT, + MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT: StaticSchema = ( + 18, + n1, + _s308, + {_s30: _s309, _s32: None}, + (_s212,), + ((4, {_s77: _s212, _s198: None}),), +) + +MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT: StaticSchema = ( + 18, + n1, + _s617, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_HEADER_DEFAULT: StaticOperationSchema = ( + 23, + n1, + _s780, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampHeaderDefault", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT: StaticSchema = ( + 18, + n1, + _s310, + {_s30: _s311, _s32: None}, + (_s212,), + ((4, {_s77: _s212, _s94: _s191, _s198: None}),), +) + +MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT: StaticSchema = ( + 18, + n1, + _s618, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_HEADER_EPOCH: StaticOperationSchema = ( + 23, + n1, + _s781, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampHeaderEpoch", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT, + MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT: StaticSchema = ( + 18, + n1, + _s312, + {_s30: _s313, _s32: None}, + (_s212,), + ((4, 9),), +) + +MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT: StaticSchema = ( + 18, + n1, + _s619, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_PATH_DEFAULT: StaticOperationSchema = ( + 23, + n1, + _s782, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampPathDefault/{timestamp}", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT: StaticSchema = ( + 18, + n1, + _s314, + {_s30: _s315, _s32: None}, + (_s212,), + ((4, {_s94: _s191, _s197: None, _s198: None}),), +) + +MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT: StaticSchema = ( + 18, + n1, + _s620, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_PATH_EPOCH: StaticOperationSchema = ( + 23, + n1, + _s783, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampPathEpoch/{timestamp}", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT, + MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT: StaticSchema = ( + 18, + n1, + _s316, + {_s30: _s317, _s32: None}, + (_s212,), + ((4, {_s94: _s193, _s197: None, _s198: None}),), +) + +MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT: StaticSchema = ( + 18, + n1, + _s621, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_PATH_HTTP_DATE: StaticOperationSchema = ( + 23, + n1, + _s784, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampPathHttpDate/{timestamp}", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT, + MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT: StaticSchema = ( + 18, + n1, + _s318, + {_s30: _s319, _s32: None}, + (_s212,), + ((4, {_s34: _s212, _s198: None}),), +) + +MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT: StaticSchema = ( + 18, + n1, + _s622, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_QUERY_DEFAULT: StaticOperationSchema = ( + 23, + n1, + _s785, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampQueryDefault", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT, + MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT: StaticSchema = ( + 18, + n1, + _s320, + {_s30: _s321, _s32: None}, + (_s212,), + ((4, {_s34: _s212, _s94: _s191, _s198: None}),), +) + +MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT: StaticSchema = ( + 18, + n1, + _s623, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_QUERY_EPOCH: StaticOperationSchema = ( + 23, + n1, + _s786, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampQueryEpoch", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT, + MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT, + (), +) + +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT: StaticSchema = ( + 18, + n1, + _s322, + {_s30: _s323, _s32: None}, + (_s212,), + ((4, {_s34: _s212, _s94: _s193, _s198: None}),), +) + +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT: StaticSchema = ( + 18, + n1, + _s624, + {_s30: _s435, _s92: None}, +) + +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE: StaticOperationSchema = ( + 23, + n1, + _s787, + { + _s714: MappingProxyType( + {"uri": "/MalformedTimestampQueryHttpDate", "method": "POST"} + ) + }, + MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT, + MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT, + (), +) + +SIMPLE_UNION: StaticSchema = ( + 19, + n1, + _s324, + 0, + (_s290, _s207), + ((7, 0), (3, 0)), +) + +MALFORMED_UNION_INPUT: StaticSchema = ( + 18, + n1, + _s325, + {_s30: _s326, _s32: None}, + (_s327,), + ((SIMPLE_UNION, 0),), +) + +MALFORMED_UNION_OUTPUT: StaticSchema = ( + 18, + n1, + _s625, + {_s30: _s435, _s92: None}, +) + +MALFORMED_UNION: StaticOperationSchema = ( + 23, + n1, + _s788, + {_s714: MappingProxyType({"uri": "/MalformedUnion", "method": "POST"})}, + MALFORMED_UNION_INPUT, + MALFORMED_UNION_OUTPUT, + (), +) + +MEDIA_TYPE_HEADER_INPUT: StaticSchema = ( + 18, + n1, + _s328, + {_s30: _s329, _s32: None}, + (_s330,), + ((lambda: schemas.JSON_VALUE, {_s77: _s331}),), +) + +MEDIA_TYPE_HEADER_OUTPUT: StaticSchema = ( + 18, + n1, + _s332, + {_s30: _s333, _s92: None}, + (_s330,), + ((lambda: schemas.JSON_VALUE, {_s77: _s331}),), +) + +MEDIA_TYPE_HEADER: StaticOperationSchema = ( + 23, + n1, + _s789, + {_s714: MappingProxyType({"uri": "/MediaTypeHeader", "method": "GET"})}, + MEDIA_TYPE_HEADER_INPUT, + MEDIA_TYPE_HEADER_OUTPUT, + (), +) + +RENAMED_GREETING: StaticSchema = ( + 18, + n2, + _s141, + 0, + (_s334,), + ((3, 0),), +) + +NESTED_UNION: StaticSchema = ( + 19, + n1, + _s335, + 0, + (_s336,), + ((3, 0),), +) + +MY_UNION: StaticSchema = ( + 19, + n1, + _s337, + 0, + (_s336, _s338, _s339, _s340, _s341, _s342, _s343, _s344, _s345, _s346, _s347), + ( + (3, 0), + (2, 0), + (7, 0), + (1, 0), + (4, 0), + (lambda: schemas.FOO_ENUM, 0), + (lambda: schemas.STRING_LIST, 0), + (lambda: schemas.STRING_MAP, 0), + (lambda: schemas.GREETING_STRUCT, 0), + (RENAMED_GREETING, 0), + (NESTED_UNION, 0), + ), +) + +NESTED_PAYLOAD: StaticSchema = ( + 18, + n1, + _s348, + 0, + (_s148, _s349), + ((3, 0), (3, 0)), +) + +NO_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = ( + 18, + n1, + _s350, + {_s30: _s351, _s92: None}, +) + +NO_INPUT_AND_OUTPUT_INPUT: StaticSchema = ( + 18, + n1, + _s628, + {_s30: _s435, _s32: None}, +) + +NO_INPUT_AND_OUTPUT: StaticOperationSchema = ( + 23, + n1, + _s791, + {_s714: MappingProxyType({"uri": "/NoInputAndOutputOutput", "method": "POST"})}, + NO_INPUT_AND_OUTPUT_INPUT, + NO_INPUT_AND_OUTPUT_OUTPUT, + (), +) + +OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT: StaticSchema = ( + 18, + n1, + _s352, + {_s30: _s353, _s32: None}, + (_s354, _s127), + ((3, {_s34: _s355}), (3, {_s34: _s356})), +) + +OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT: StaticSchema = ( + 18, + n1, + _s638, + {_s30: _s435, _s92: None}, +) + +OMITS_NULL_SERIALIZES_EMPTY_STRING: StaticOperationSchema = ( + 23, + n1, + _s794, + { + _s714: MappingProxyType( + {"uri": "/OmitsNullSerializesEmptyString", "method": "GET"} + ) + }, + OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT, + OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT, + (), +) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_2.py b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_2.py new file mode 100644 index 000000000..766023e7a --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_2.py @@ -0,0 +1,1347 @@ +from types import MappingProxyType + +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + +from . import schemas + +n0 = "aws.protocoltests.shared" +_s0 = "StringList" +_s1 = "member" +_s3 = "IntegerList" +_s5 = "DoubleList" +_s6 = "BooleanList" +_s7 = "TimestampList" +_s9 = "FOO" +_s10 = "smithy.api#enumValue" +_s25 = "IntegerEnumList" +_s27 = "key" +_s28 = "value" +n1 = "aws.protocoltests.restjson" +_s30 = "smithy.synthetic#originalShapeId" +_s32 = "smithy.api#input" +_s34 = "smithy.api#httpQuery" +_s36 = "queryStringList" +_s44 = "queryIntegerList" +_s52 = "queryDoubleList" +_s55 = "queryBooleanList" +_s58 = "queryTimestampList" +_s61 = "queryEnumList" +_s62 = "EnumList" +_s64 = "queryIntegerEnumList" +_s68 = "smithy.api#default" +_s70 = "smithy.api#jsonName" +_s77 = "smithy.api#httpHeader" +_s79 = "TopLevel" +_s83 = "baz" +_s92 = "smithy.api#output" +_s100 = "Document" +_s106 = "defaultString" +_s107 = "hi" +_s108 = "defaultBoolean" +_s109 = "defaultList" +_s110 = "defaultDocumentMap" +_s111 = "defaultDocumentString" +_s112 = "defaultDocumentBoolean" +_s113 = "defaultDocumentList" +_s114 = "defaultNullDocument" +_s115 = "defaultTimestamp" +_s116 = "defaultBlob" +_s117 = "YWJj" +_s118 = "defaultByte" +_s119 = "defaultShort" +_s120 = "defaultInteger" +_s121 = "defaultLong" +_s122 = "defaultFloat" +_s123 = "defaultDouble" +_s124 = "defaultMap" +_s125 = "defaultEnum" +_s126 = "defaultIntEnum" +_s127 = "emptyString" +_s128 = "" +_s129 = "falseBoolean" +_s130 = "emptyBlob" +_s131 = "zeroByte" +_s132 = "zeroShort" +_s133 = "zeroInteger" +_s134 = "zeroLong" +_s135 = "zeroFloat" +_s136 = "zeroDouble" +_s148 = "greeting" +_s178 = "foo" +_s224 = "smithy.api#mediaType" +_s229 = "payload" +_s236 = "blob" +_s336 = "stringValue" +_s357 = "OmitsSerializingEmptyListsInput" +_s358 = "aws.protocoltests.restjson#OmitsSerializingEmptyListsInput" +_s359 = "OperationWithDefaultsInput" +_s360 = "aws.protocoltests.restjson#OperationWithDefaultsInput" +_s361 = "defaults" +_s362 = "clientOptionalDefaults" +_s363 = "topLevelDefault" +_s364 = "otherTopLevelDefault" +_s365 = "OperationWithDefaultsOutput" +_s366 = "aws.protocoltests.restjson#OperationWithDefaultsOutput" +_s367 = "dialog" +_s368 = "dialogList" +_s369 = "dialogMap" +_s370 = "OperationWithNestedStructureInput" +_s371 = "aws.protocoltests.restjson#OperationWithNestedStructureInput" +_s372 = "topLevel" +_s373 = "OperationWithNestedStructureOutput" +_s374 = "aws.protocoltests.restjson#OperationWithNestedStructureOutput" +_s375 = "PayloadConfig" +_s376 = "data" +_s377 = "PlayerAction" +_s378 = "quit" +_s379 = "PostPlayerActionInput" +_s380 = "aws.protocoltests.restjson#PostPlayerActionInput" +_s381 = "action" +_s382 = "PostPlayerActionOutput" +_s383 = "aws.protocoltests.restjson#PostPlayerActionOutput" +_s384 = "UnionWithJsonName" +_s385 = "bar" +_s386 = "_baz" +_s387 = "PostUnionWithJsonNameInput" +_s388 = "aws.protocoltests.restjson#PostUnionWithJsonNameInput" +_s389 = "PostUnionWithJsonNameOutput" +_s390 = "aws.protocoltests.restjson#PostUnionWithJsonNameOutput" +_s391 = "PutWithContentEncodingInput" +_s392 = "aws.protocoltests.restjson#PutWithContentEncodingInput" +_s393 = "encoding" +_s394 = "Content-Encoding" +_s395 = "QueryIdempotencyTokenAutoFillInput" +_s396 = "aws.protocoltests.restjson#QueryIdempotencyTokenAutoFillInput" +_s397 = "token" +_s398 = "smithy.api#idempotencyToken" +_s399 = "QueryMap" +_s400 = "QueryParamsAsStringListMapInput" +_s401 = "aws.protocoltests.restjson#QueryParamsAsStringListMapInput" +_s402 = "qux" +_s403 = "corge" +_s404 = "QueryPrecedenceInput" +_s405 = "aws.protocoltests.restjson#QueryPrecedenceInput" +_s406 = "ResponseCodeRequiredOutput" +_s407 = "aws.protocoltests.restjson#ResponseCodeRequiredOutput" +_s408 = "responseCode" +_s409 = "SparseBooleanMap" +_s410 = "SparseNumberMap" +_s411 = "SparseSetMap" +_s412 = "SparseStructMap" +_s413 = "StringEnum" +_s414 = "V" +_s415 = "enumvalue" +_s416 = "StructureListMember" +_s417 = "a" +_s418 = "b" +_s419 = "other" +_s420 = "StructureList" +_s421 = "TestConfig" +_s422 = "timeout" +_s423 = "UnionPayload" +_s424 = "FooEnumMap" +_s425 = "FooEnumSet" +_s426 = "IntegerEnumMap" +_s427 = "IntegerEnumSet" +_s428 = "NestedStringList" +_s429 = "SparseShortList" +_s430 = "SparseStringList" +_s431 = "SparseStringMap" +_s432 = "TextPlainBlob" +_s433 = "text/plain" +_s435 = "smithy.api#Unit" +_s439 = "DocumentTypeInput" +_s440 = "aws.protocoltests.restjson#DocumentTypeInputOutput" +_s441 = "documentValue" +_s442 = "DocumentTypeOutput" +_s443 = "DocumentTypeAsMapValueInput" +_s444 = "aws.protocoltests.restjson#DocumentTypeAsMapValueInputOutput" +_s445 = "docValuedMap" +_s446 = "DocumentTypeAsMapValueOutput" +_s447 = "DocumentTypeAsPayloadInput" +_s448 = "aws.protocoltests.restjson#DocumentTypeAsPayloadInputOutput" +_s449 = "DocumentTypeAsPayloadOutput" +_s450 = "EndpointOperationInput" +_s451 = "EndpointOperationOutput" +_s452 = "EndpointWithHostLabelOperationInput" +_s453 = "aws.protocoltests.restjson#HostLabelInput" +_s454 = "label" +_s455 = "EndpointWithHostLabelOperationOutput" +_s458 = "HostWithPathOperationInput" +_s459 = "HostWithPathOperationOutput" +_s460 = "HttpChecksumRequiredInput" +_s461 = "aws.protocoltests.restjson#HttpChecksumRequiredInputOutput" +_s462 = "HttpChecksumRequiredOutput" +_s463 = "HttpEnumPayloadInput" +_s464 = "aws.protocoltests.restjson#EnumPayloadInput" +_s465 = "HttpEnumPayloadOutput" +_s466 = "HttpPayloadTraitsInput" +_s467 = "aws.protocoltests.restjson#HttpPayloadTraitsInputOutput" +_s468 = "X-Foo" +_s469 = "HttpPayloadTraitsOutput" +_s470 = "HttpPayloadTraitsWithMediaTypeInput" +_s471 = "aws.protocoltests.restjson#HttpPayloadTraitsWithMediaTypeInputOutput" +_s472 = "HttpPayloadTraitsWithMediaTypeOutput" +_s473 = "HttpPayloadWithStructureInput" +_s474 = "aws.protocoltests.restjson#HttpPayloadWithStructureInputOutput" +_s475 = "nested" +_s476 = "HttpPayloadWithStructureOutput" +_s477 = "HttpPayloadWithUnionInput" +_s478 = "aws.protocoltests.restjson#HttpPayloadWithUnionInputOutput" +_s479 = "HttpPayloadWithUnionOutput" +_s480 = "HttpQueryParamsOnlyOperationInput" +_s481 = "aws.protocoltests.restjson#HttpQueryParamsOnlyInput" +_s482 = "queryMap" +_s483 = "HttpQueryParamsOnlyOperationOutput" +_s490 = "HttpStringPayloadInput" +_s491 = "aws.protocoltests.restjson#StringPayloadInput" +_s492 = "HttpStringPayloadOutput" +_s494 = "InputAndOutputWithHeadersInput" +_s495 = "aws.protocoltests.restjson#InputAndOutputWithHeadersIO" +_s496 = "headerString" +_s497 = "X-String" +_s498 = "headerByte" +_s499 = "X-Byte" +_s500 = "headerShort" +_s501 = "X-Short" +_s502 = "headerInteger" +_s503 = "X-Integer" +_s504 = "headerLong" +_s505 = "X-Long" +_s506 = "headerFloat" +_s507 = "X-Float" +_s508 = "headerDouble" +_s509 = "X-Double" +_s510 = "headerTrueBool" +_s511 = "X-Boolean1" +_s512 = "headerFalseBool" +_s513 = "X-Boolean2" +_s514 = "headerStringList" +_s515 = "X-StringList" +_s516 = "headerStringSet" +_s517 = "X-StringSet" +_s518 = "headerIntegerList" +_s519 = "X-IntegerList" +_s520 = "headerBooleanList" +_s521 = "X-BooleanList" +_s522 = "headerTimestampList" +_s523 = "X-TimestampList" +_s524 = "headerEnum" +_s525 = "X-Enum" +_s526 = "headerEnumList" +_s527 = "X-EnumList" +_s528 = "headerIntegerEnum" +_s529 = "X-IntegerEnum" +_s530 = "headerIntegerEnumList" +_s531 = "X-IntegerEnumList" +_s532 = "InputAndOutputWithHeadersOutput" +_s639 = "OmitsSerializingEmptyListsOutput" +_s640 = "PutWithContentEncodingOutput" +_s641 = "QueryIdempotencyTokenAutoFillOutput" +_s642 = "QueryParamsAsStringListMapOutput" +_s643 = "QueryPrecedenceOutput" +_s650 = "ResponseCodeRequiredInput" +_s714 = "smithy.api#http" +_s719 = "DocumentType" +_s720 = "DocumentTypeAsMapValue" +_s721 = "DocumentTypeAsPayload" +_s723 = "EndpointOperation" +_s724 = "smithy.api#endpoint" +_s725 = "EndpointWithHostLabelOperation" +_s728 = "HostWithPathOperation" +_s729 = "HttpChecksumRequired" +_s730 = "smithy.api#httpChecksumRequired" +_s732 = "HttpEnumPayload" +_s733 = "HttpPayloadTraits" +_s734 = "HttpPayloadTraitsWithMediaType" +_s735 = "HttpPayloadWithStructure" +_s736 = "HttpPayloadWithUnion" +_s739 = "HttpQueryParamsOnlyOperation" +_s746 = "HttpStringPayload" +_s748 = "InputAndOutputWithHeaders" +_s795 = "OmitsSerializingEmptyLists" +_s796 = "OperationWithDefaults" +_s797 = "OperationWithNestedStructure" +_s798 = "PostPlayerAction" +_s799 = "PostUnionWithJsonName" +_s800 = "PutWithContentEncoding" +_s801 = "smithy.api#requestCompression" +_s802 = "QueryIdempotencyTokenAutoFill" +_s803 = "QueryParamsAsStringListMap" +_s804 = "QueryPrecedence" +_s807 = "ResponseCodeRequired" + +DOCUMENT: StaticSchema = ( + 13, + n1, + _s100, + 0, +) + +OMITS_SERIALIZING_EMPTY_LISTS_INPUT: StaticSchema = ( + 18, + n1, + _s357, + {_s30: _s358, _s32: None}, + (_s36, _s44, _s52, _s55, _s58, _s61, _s64), + ( + (lambda: schemas.STRING_LIST, {_s34: _s0}), + (lambda: schemas.INTEGER_LIST, {_s34: _s3}), + (lambda: schemas.DOUBLE_LIST, {_s34: _s5}), + (lambda: schemas.BOOLEAN_LIST, {_s34: _s6}), + (lambda: schemas.TIMESTAMP_LIST, {_s34: _s7}), + (lambda: schemas.FOO_ENUM_LIST, {_s34: _s62}), + (lambda: schemas.INTEGER_ENUM_LIST, {_s34: _s25}), + ), +) + +OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT: StaticSchema = ( + 18, + n1, + _s639, + {_s30: _s435, _s92: None}, +) + +OMITS_SERIALIZING_EMPTY_LISTS: StaticOperationSchema = ( + 23, + n1, + _s795, + {_s714: MappingProxyType({"uri": "/OmitsSerializingEmptyLists", "method": "POST"})}, + OMITS_SERIALIZING_EMPTY_LISTS_INPUT, + OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT, + (), +) + +OPERATION_WITH_DEFAULTS_INPUT: StaticSchema = ( + 18, + n1, + _s359, + {_s30: _s360, _s32: None}, + (_s361, _s362, _s363, _s364), + ( + (lambda: schemas.DEFAULTS, 0), + (lambda: schemas.CLIENT_OPTIONAL_DEFAULTS, 0), + (3, {_s68: _s107}), + (7, {_s68: 0}), + ), +) + +OPERATION_WITH_DEFAULTS_OUTPUT: StaticSchema = ( + 18, + n1, + _s365, + {_s30: _s366, _s92: None}, + ( + _s106, + _s108, + _s109, + _s110, + _s111, + _s112, + _s113, + _s114, + _s115, + _s116, + _s118, + _s119, + _s120, + _s121, + _s122, + _s123, + _s124, + _s125, + _s126, + _s127, + _s129, + _s130, + _s131, + _s132, + _s133, + _s134, + _s135, + _s136, + ), + ( + (3, {_s68: _s107}), + (2, {_s68: True}), + (lambda: schemas.TEST_STRING_LIST, {_s68: ()}), + (DOCUMENT, {_s68: MappingProxyType[str, object]({})}), + (DOCUMENT, {_s68: _s107}), + (DOCUMENT, {_s68: True}), + (DOCUMENT, {_s68: ()}), + (DOCUMENT, {_s68: None}), + (4, {_s68: 0}), + (1, {_s68: _s117}), + (5, {_s68: 1}), + (6, {_s68: 1}), + (7, {_s68: 10}), + (8, {_s68: 100}), + (9, {_s68: 1.0}), + (10, {_s68: 1.0}), + (lambda: schemas.TEST_STRING_MAP, {_s68: MappingProxyType[str, object]({})}), + (lambda: schemas.TEST_ENUM, {_s68: _s9}), + (lambda: schemas.TEST_INT_ENUM, {_s68: 1}), + (3, {_s68: _s128}), + (2, {_s68: False}), + (1, {_s68: _s128}), + (5, {_s68: 0}), + (6, {_s68: 0}), + (7, {_s68: 0}), + (8, {_s68: 0}), + (9, {_s68: 0.0}), + (10, {_s68: 0.0}), + ), +) + +OPERATION_WITH_DEFAULTS: StaticOperationSchema = ( + 23, + n1, + _s796, + {_s714: MappingProxyType({"uri": "/OperationWithDefaults", "method": "POST"})}, + OPERATION_WITH_DEFAULTS_INPUT, + OPERATION_WITH_DEFAULTS_OUTPUT, + (), +) + +TOP_LEVEL: StaticSchema = ( + 18, + n1, + _s79, + 0, + (_s367, _s368, _s369), + ( + (lambda: schemas.DIALOG, 1), + (lambda: schemas.DIALOG_LIST, {_s68: ()}), + (lambda: schemas.DIALOG_MAP, {_s68: MappingProxyType[str, object]({})}), + ), +) + +OPERATION_WITH_NESTED_STRUCTURE_INPUT: StaticSchema = ( + 18, + n1, + _s370, + {_s30: _s371, _s32: None}, + (_s372,), + ((TOP_LEVEL, 1),), +) + +OPERATION_WITH_NESTED_STRUCTURE_OUTPUT: StaticSchema = ( + 18, + n1, + _s373, + {_s30: _s374, _s92: None}, + (_s367, _s368, _s369), + ( + (lambda: schemas.DIALOG, 1), + (lambda: schemas.DIALOG_LIST, {_s68: ()}), + (lambda: schemas.DIALOG_MAP, {_s68: MappingProxyType[str, object]({})}), + ), +) + +OPERATION_WITH_NESTED_STRUCTURE: StaticOperationSchema = ( + 23, + n1, + _s797, + { + _s714: MappingProxyType( + {"uri": "/OperationWithNestedStructure", "method": "POST"} + ) + }, + OPERATION_WITH_NESTED_STRUCTURE_INPUT, + OPERATION_WITH_NESTED_STRUCTURE_OUTPUT, + (), +) + +PAYLOAD_CONFIG: StaticSchema = ( + 18, + n1, + _s375, + 0, + (_s376,), + ((7, 0),), +) + +PLAYER_ACTION: StaticSchema = ( + 19, + n1, + _s377, + 0, + (_s378,), + ((-1, 0),), +) + +POST_PLAYER_ACTION_INPUT: StaticSchema = ( + 18, + n1, + _s379, + {_s30: _s380, _s32: None}, + (_s381,), + ((PLAYER_ACTION, 0),), +) + +POST_PLAYER_ACTION_OUTPUT: StaticSchema = ( + 18, + n1, + _s382, + {_s30: _s383, _s92: None}, + (_s381,), + ((PLAYER_ACTION, 1),), +) + +POST_PLAYER_ACTION: StaticOperationSchema = ( + 23, + n1, + _s798, + {_s714: MappingProxyType({"uri": "/PostPlayerAction", "method": "POST"})}, + POST_PLAYER_ACTION_INPUT, + POST_PLAYER_ACTION_OUTPUT, + (), +) + +UNION_WITH_JSON_NAME: StaticSchema = ( + 19, + n1, + _s384, + 0, + (_s178, _s385, _s83), + ((3, {_s70: _s9}), (3, 0), (3, {_s70: _s386})), +) + +POST_UNION_WITH_JSON_NAME_INPUT: StaticSchema = ( + 18, + n1, + _s387, + {_s30: _s388, _s32: None}, + (_s28,), + ((UNION_WITH_JSON_NAME, 0),), +) + +POST_UNION_WITH_JSON_NAME_OUTPUT: StaticSchema = ( + 18, + n1, + _s389, + {_s30: _s390, _s92: None}, + (_s28,), + ((UNION_WITH_JSON_NAME, 1),), +) + +POST_UNION_WITH_JSON_NAME: StaticOperationSchema = ( + 23, + n1, + _s799, + {_s714: MappingProxyType({"uri": "/PostUnionWithJsonName", "method": "POST"})}, + POST_UNION_WITH_JSON_NAME_INPUT, + POST_UNION_WITH_JSON_NAME_OUTPUT, + (), +) + +PUT_WITH_CONTENT_ENCODING_INPUT: StaticSchema = ( + 18, + n1, + _s391, + {_s30: _s392, _s32: None}, + (_s393, _s376), + ((3, {_s77: _s394}), (3, 0)), +) + +PUT_WITH_CONTENT_ENCODING_OUTPUT: StaticSchema = ( + 18, + n1, + _s640, + {_s30: _s435, _s92: None}, +) + +PUT_WITH_CONTENT_ENCODING: StaticOperationSchema = ( + 23, + n1, + _s800, + { + _s714: MappingProxyType( + {"method": "POST", "uri": "/requestcompression/putcontentwithencoding"} + ), + _s801: MappingProxyType({"encodings": ("gzip",)}), + }, + PUT_WITH_CONTENT_ENCODING_INPUT, + PUT_WITH_CONTENT_ENCODING_OUTPUT, + (), +) + +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT: StaticSchema = ( + 18, + n1, + _s395, + {_s30: _s396, _s32: None}, + (_s397,), + ((3, {_s34: _s397, _s398: None}),), +) + +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT: StaticSchema = ( + 18, + n1, + _s641, + {_s30: _s435, _s92: None}, +) + +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL: StaticOperationSchema = ( + 23, + n1, + _s802, + { + _s714: MappingProxyType( + {"uri": "/QueryIdempotencyTokenAutoFill", "method": "POST"} + ) + }, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT, + QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT, + (), +) + +QUERY_MAP: StaticSchema = ( + 17, + n1, + _s399, + 0, + (_s27, _s28), + ((3, 0), (3, 0)), +) + +QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT: StaticSchema = ( + 18, + n1, + _s400, + {_s30: _s401, _s32: None}, + (_s402, _s178), + ((3, {_s34: _s403}), (lambda: schemas.STRING_LIST_MAP, 1024)), +) + +QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT: StaticSchema = ( + 18, + n1, + _s642, + {_s30: _s435, _s92: None}, +) + +QUERY_PARAMS_AS_STRING_LIST_MAP: StaticOperationSchema = ( + 23, + n1, + _s803, + {_s714: MappingProxyType({"uri": "/StringListMap", "method": "POST"})}, + QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT, + QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT, + (), +) + +QUERY_PRECEDENCE_INPUT: StaticSchema = ( + 18, + n1, + _s404, + {_s30: _s405, _s32: None}, + (_s178, _s83), + ((3, {_s34: _s385}), (lambda: schemas.STRING_MAP, 1024)), +) + +QUERY_PRECEDENCE_OUTPUT: StaticSchema = ( + 18, + n1, + _s643, + {_s30: _s435, _s92: None}, +) + +QUERY_PRECEDENCE: StaticOperationSchema = ( + 23, + n1, + _s804, + {_s714: MappingProxyType({"uri": "/Precedence", "method": "POST"})}, + QUERY_PRECEDENCE_INPUT, + QUERY_PRECEDENCE_OUTPUT, + (), +) + +RESPONSE_CODE_REQUIRED_OUTPUT: StaticSchema = ( + 18, + n1, + _s406, + {_s30: _s407, _s92: None}, + (_s408,), + ((7, 129),), +) + +RESPONSE_CODE_REQUIRED_INPUT: StaticSchema = ( + 18, + n1, + _s650, + {_s30: _s435, _s32: None}, +) + +RESPONSE_CODE_REQUIRED: StaticOperationSchema = ( + 23, + n1, + _s807, + { + _s714: MappingProxyType( + {"method": "GET", "uri": "/responseCodeRequired", "code": 200} + ) + }, + RESPONSE_CODE_REQUIRED_INPUT, + RESPONSE_CODE_REQUIRED_OUTPUT, + (), +) + +SPARSE_BOOLEAN_MAP: StaticSchema = ( + 17, + n1, + _s409, + 64, + (_s27, _s28), + ((3, 0), (2, 0)), +) + +SPARSE_NUMBER_MAP: StaticSchema = ( + 17, + n1, + _s410, + 64, + (_s27, _s28), + ((3, 0), (7, 0)), +) + +SPARSE_SET_MAP: StaticSchema = ( + 17, + n1, + _s411, + 64, + (_s27, _s28), + ((3, 0), (lambda: schemas.STRING_SET, 0)), +) + +SPARSE_STRUCT_MAP: StaticSchema = ( + 17, + n1, + _s412, + 64, + (_s27, _s28), + ((3, 0), (lambda: schemas.GREETING_STRUCT, 0)), +) + +STRING_ENUM: StaticSchema = ( + 14, + n1, + _s413, + 0, + (_s414,), + ((-1, {_s10: _s415}),), +) + +STRUCTURE_LIST_MEMBER: StaticSchema = ( + 18, + n1, + _s416, + 0, + (_s417, _s418), + ((3, {_s70: _s28}), (3, {_s70: _s419})), +) + +STRUCTURE_LIST: StaticSchema = ( + 16, + n1, + _s420, + 0, + (_s1,), + ((STRUCTURE_LIST_MEMBER, 0),), +) + +TEST_CONFIG: StaticSchema = ( + 18, + n1, + _s421, + 0, + (_s422,), + ((7, 0),), +) + +UNION_PAYLOAD: StaticSchema = ( + 19, + n1, + _s423, + 0, + (_s148,), + ((3, 0),), +) + +FOO_ENUM_MAP: StaticSchema = ( + 17, + n0, + _s424, + 0, + (_s27, _s28), + ((3, 0), (lambda: schemas.FOO_ENUM, 0)), +) + +FOO_ENUM_SET: StaticSchema = ( + 16, + n0, + _s425, + 0, + (_s1,), + ((lambda: schemas.FOO_ENUM, 0),), +) + +INTEGER_ENUM_MAP: StaticSchema = ( + 17, + n0, + _s426, + 0, + (_s27, _s28), + ((3, 0), (lambda: schemas.INTEGER_ENUM, 0)), +) + +INTEGER_ENUM_SET: StaticSchema = ( + 16, + n0, + _s427, + 0, + (_s1,), + ((lambda: schemas.INTEGER_ENUM, 0),), +) + +NESTED_STRING_LIST: StaticSchema = ( + 16, + n0, + _s428, + 0, + (_s1,), + ((lambda: schemas.STRING_LIST, 0),), +) + +SPARSE_SHORT_LIST: StaticSchema = ( + 16, + n0, + _s429, + 64, + (_s1,), + ((6, 0),), +) + +SPARSE_STRING_LIST: StaticSchema = ( + 16, + n0, + _s430, + 64, + (_s1,), + ((3, 0),), +) + +SPARSE_STRING_MAP: StaticSchema = ( + 17, + n0, + _s431, + 64, + (_s27, _s28), + ((3, 0), (3, 0)), +) + +TEXT_PLAIN_BLOB: StaticSchema = ( + 1, + n0, + _s432, + {_s224: _s433}, +) + +DOCUMENT_TYPE_INPUT: StaticSchema = ( + 18, + n1, + _s439, + {_s30: _s440, _s32: None}, + (_s336, _s441), + ((3, 0), (DOCUMENT, 0)), +) + +DOCUMENT_TYPE_OUTPUT: StaticSchema = ( + 18, + n1, + _s442, + {_s30: _s440, _s92: None}, + (_s336, _s441), + ((3, 0), (DOCUMENT, 0)), +) + +DOCUMENT_TYPE: StaticOperationSchema = ( + 23, + n1, + _s719, + {_s714: MappingProxyType({"uri": "/DocumentType", "method": "PUT"})}, + DOCUMENT_TYPE_INPUT, + DOCUMENT_TYPE_OUTPUT, + (), +) + +DOCUMENT_TYPE_AS_MAP_VALUE_INPUT: StaticSchema = ( + 18, + n1, + _s443, + {_s30: _s444, _s32: None}, + (_s445,), + ((lambda: schemas.DOCUMENT_VALUED_MAP, 0),), +) + +DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT: StaticSchema = ( + 18, + n1, + _s446, + {_s30: _s444, _s92: None}, + (_s445,), + ((lambda: schemas.DOCUMENT_VALUED_MAP, 0),), +) + +DOCUMENT_TYPE_AS_MAP_VALUE: StaticOperationSchema = ( + 23, + n1, + _s720, + {_s714: MappingProxyType({"uri": "/DocumentTypeAsMapValue", "method": "PUT"})}, + DOCUMENT_TYPE_AS_MAP_VALUE_INPUT, + DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT, + (), +) + +DOCUMENT_TYPE_AS_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s447, + {_s30: _s448, _s32: None}, + (_s441,), + ((DOCUMENT, 16),), +) + +DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s449, + {_s30: _s448, _s92: None}, + (_s441,), + ((DOCUMENT, 16),), +) + +DOCUMENT_TYPE_AS_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s721, + {_s714: MappingProxyType({"uri": "/DocumentTypeAsPayload", "method": "PUT"})}, + DOCUMENT_TYPE_AS_PAYLOAD_INPUT, + DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT, + (), +) + +ENDPOINT_OPERATION_INPUT: StaticSchema = ( + 18, + n1, + _s450, + {_s30: _s435, _s32: None}, +) + +ENDPOINT_OPERATION_OUTPUT: StaticSchema = ( + 18, + n1, + _s451, + {_s30: _s435, _s92: None}, +) + +ENDPOINT_OPERATION: StaticOperationSchema = ( + 23, + n1, + _s723, + { + _s724: MappingProxyType({"hostPrefix": "foo."}), + _s714: MappingProxyType({"uri": "/EndpointOperation", "method": "POST"}), + }, + ENDPOINT_OPERATION_INPUT, + ENDPOINT_OPERATION_OUTPUT, + (), +) + +ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT: StaticSchema = ( + 18, + n1, + _s452, + {_s30: _s453, _s32: None}, + (_s454,), + ((3, 257),), +) + +ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT: StaticSchema = ( + 18, + n1, + _s455, + {_s30: _s435, _s92: None}, +) + +ENDPOINT_WITH_HOST_LABEL_OPERATION: StaticOperationSchema = ( + 23, + n1, + _s725, + { + _s724: MappingProxyType({"hostPrefix": "foo.{label}."}), + _s714: MappingProxyType( + {"uri": "/EndpointWithHostLabelOperation", "method": "POST"} + ), + }, + ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT, + ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT, + (), +) + +HOST_WITH_PATH_OPERATION_INPUT: StaticSchema = ( + 18, + n1, + _s458, + {_s30: _s435, _s32: None}, +) + +HOST_WITH_PATH_OPERATION_OUTPUT: StaticSchema = ( + 18, + n1, + _s459, + {_s30: _s435, _s92: None}, +) + +HOST_WITH_PATH_OPERATION: StaticOperationSchema = ( + 23, + n1, + _s728, + {_s714: MappingProxyType({"uri": "/HostWithPathOperation", "method": "GET"})}, + HOST_WITH_PATH_OPERATION_INPUT, + HOST_WITH_PATH_OPERATION_OUTPUT, + (), +) + +HTTP_CHECKSUM_REQUIRED_INPUT: StaticSchema = ( + 18, + n1, + _s460, + {_s30: _s461, _s32: None}, + (_s178,), + ((3, 0),), +) + +HTTP_CHECKSUM_REQUIRED_OUTPUT: StaticSchema = ( + 18, + n1, + _s462, + {_s30: _s461, _s92: None}, + (_s178,), + ((3, 0),), +) + +HTTP_CHECKSUM_REQUIRED: StaticOperationSchema = ( + 23, + n1, + _s729, + { + _s714: MappingProxyType({"uri": "/HttpChecksumRequired", "method": "POST"}), + _s730: None, + }, + HTTP_CHECKSUM_REQUIRED_INPUT, + HTTP_CHECKSUM_REQUIRED_OUTPUT, + (), +) + +HTTP_ENUM_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s463, + {_s30: _s464, _s32: None}, + (_s229,), + ((STRING_ENUM, 16),), +) + +HTTP_ENUM_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s465, + {_s30: _s464, _s92: None}, + (_s229,), + ((STRING_ENUM, 16),), +) + +HTTP_ENUM_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s732, + {_s714: MappingProxyType({"uri": "/EnumPayload", "method": "POST"})}, + HTTP_ENUM_PAYLOAD_INPUT, + HTTP_ENUM_PAYLOAD_OUTPUT, + (), +) + +HTTP_PAYLOAD_TRAITS_INPUT: StaticSchema = ( + 18, + n1, + _s466, + {_s30: _s467, _s32: None}, + (_s178, _s236), + ((3, {_s77: _s468}), (1, 16)), +) + +HTTP_PAYLOAD_TRAITS_OUTPUT: StaticSchema = ( + 18, + n1, + _s469, + {_s30: _s467, _s92: None}, + (_s178, _s236), + ((3, {_s77: _s468}), (1, 16)), +) + +HTTP_PAYLOAD_TRAITS: StaticOperationSchema = ( + 23, + n1, + _s733, + {_s714: MappingProxyType({"uri": "/HttpPayloadTraits", "method": "POST"})}, + HTTP_PAYLOAD_TRAITS_INPUT, + HTTP_PAYLOAD_TRAITS_OUTPUT, + (), +) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT: StaticSchema = ( + 18, + n1, + _s470, + {_s30: _s471, _s32: None}, + (_s178, _s236), + ((3, {_s77: _s468}), (TEXT_PLAIN_BLOB, 16)), +) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT: StaticSchema = ( + 18, + n1, + _s472, + {_s30: _s471, _s92: None}, + (_s178, _s236), + ((3, {_s77: _s468}), (TEXT_PLAIN_BLOB, 16)), +) + +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE: StaticOperationSchema = ( + 23, + n1, + _s734, + { + _s714: MappingProxyType( + {"uri": "/HttpPayloadTraitsWithMediaType", "method": "POST"} + ) + }, + HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT, + HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT, + (), +) + +HTTP_PAYLOAD_WITH_STRUCTURE_INPUT: StaticSchema = ( + 18, + n1, + _s473, + {_s30: _s474, _s32: None}, + (_s475,), + ((lambda: schemas.NESTED_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT: StaticSchema = ( + 18, + n1, + _s476, + {_s30: _s474, _s92: None}, + (_s475,), + ((lambda: schemas.NESTED_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_STRUCTURE: StaticOperationSchema = ( + 23, + n1, + _s735, + {_s714: MappingProxyType({"uri": "/HttpPayloadWithStructure", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_STRUCTURE_INPUT, + HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT, + (), +) + +HTTP_PAYLOAD_WITH_UNION_INPUT: StaticSchema = ( + 18, + n1, + _s477, + {_s30: _s478, _s32: None}, + (_s475,), + ((UNION_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_UNION_OUTPUT: StaticSchema = ( + 18, + n1, + _s479, + {_s30: _s478, _s92: None}, + (_s475,), + ((UNION_PAYLOAD, 16),), +) + +HTTP_PAYLOAD_WITH_UNION: StaticOperationSchema = ( + 23, + n1, + _s736, + {_s714: MappingProxyType({"uri": "/HttpPayloadWithUnion", "method": "PUT"})}, + HTTP_PAYLOAD_WITH_UNION_INPUT, + HTTP_PAYLOAD_WITH_UNION_OUTPUT, + (), +) + +HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT: StaticSchema = ( + 18, + n1, + _s480, + {_s30: _s481, _s32: None}, + (_s482,), + ((QUERY_MAP, 1024),), +) + +HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT: StaticSchema = ( + 18, + n1, + _s483, + {_s30: _s435, _s92: None}, +) + +HTTP_QUERY_PARAMS_ONLY_OPERATION: StaticOperationSchema = ( + 23, + n1, + _s739, + {_s714: MappingProxyType({"uri": "/http-query-params-only", "method": "GET"})}, + HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT, + HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT, + (), +) + +HTTP_STRING_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s490, + {_s30: _s491, _s32: None}, + (_s229,), + ((3, 16),), +) + +HTTP_STRING_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s492, + {_s30: _s491, _s92: None}, + (_s229,), + ((3, 16),), +) + +HTTP_STRING_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s746, + {_s714: MappingProxyType({"uri": "/StringPayload", "method": "POST"})}, + HTTP_STRING_PAYLOAD_INPUT, + HTTP_STRING_PAYLOAD_OUTPUT, + (), +) + +INPUT_AND_OUTPUT_WITH_HEADERS_INPUT: StaticSchema = ( + 18, + n1, + _s494, + {_s30: _s495, _s32: None}, + ( + _s496, + _s498, + _s500, + _s502, + _s504, + _s506, + _s508, + _s510, + _s512, + _s514, + _s516, + _s518, + _s520, + _s522, + _s524, + _s526, + _s528, + _s530, + ), + ( + (3, {_s77: _s497}), + (5, {_s77: _s499}), + (6, {_s77: _s501}), + (7, {_s77: _s503}), + (8, {_s77: _s505}), + (9, {_s77: _s507}), + (10, {_s77: _s509}), + (2, {_s77: _s511}), + (2, {_s77: _s513}), + (lambda: schemas.STRING_LIST, {_s77: _s515}), + (lambda: schemas.STRING_SET, {_s77: _s517}), + (lambda: schemas.INTEGER_LIST, {_s77: _s519}), + (lambda: schemas.BOOLEAN_LIST, {_s77: _s521}), + (lambda: schemas.TIMESTAMP_LIST, {_s77: _s523}), + (lambda: schemas.FOO_ENUM, {_s77: _s525}), + (lambda: schemas.FOO_ENUM_LIST, {_s77: _s527}), + (lambda: schemas.INTEGER_ENUM, {_s77: _s529}), + (lambda: schemas.INTEGER_ENUM_LIST, {_s77: _s531}), + ), +) + +INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT: StaticSchema = ( + 18, + n1, + _s532, + {_s30: _s495, _s92: None}, + ( + _s496, + _s498, + _s500, + _s502, + _s504, + _s506, + _s508, + _s510, + _s512, + _s514, + _s516, + _s518, + _s520, + _s522, + _s524, + _s526, + _s528, + _s530, + ), + ( + (3, {_s77: _s497}), + (5, {_s77: _s499}), + (6, {_s77: _s501}), + (7, {_s77: _s503}), + (8, {_s77: _s505}), + (9, {_s77: _s507}), + (10, {_s77: _s509}), + (2, {_s77: _s511}), + (2, {_s77: _s513}), + (lambda: schemas.STRING_LIST, {_s77: _s515}), + (lambda: schemas.STRING_SET, {_s77: _s517}), + (lambda: schemas.INTEGER_LIST, {_s77: _s519}), + (lambda: schemas.BOOLEAN_LIST, {_s77: _s521}), + (lambda: schemas.TIMESTAMP_LIST, {_s77: _s523}), + (lambda: schemas.FOO_ENUM, {_s77: _s525}), + (lambda: schemas.FOO_ENUM_LIST, {_s77: _s527}), + (lambda: schemas.INTEGER_ENUM, {_s77: _s529}), + (lambda: schemas.INTEGER_ENUM_LIST, {_s77: _s531}), + ), +) + +INPUT_AND_OUTPUT_WITH_HEADERS: StaticOperationSchema = ( + 23, + n1, + _s748, + {_s714: MappingProxyType({"uri": "/InputAndOutputWithHeaders", "method": "POST"})}, + INPUT_AND_OUTPUT_WITH_HEADERS_INPUT, + INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT, + (), +) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_3.py b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_3.py new file mode 100644 index 000000000..4cf08e848 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/_private/schemas_3.py @@ -0,0 +1,1125 @@ +from types import MappingProxyType + +from smithy_core._schema_compact import StaticOperationSchema, StaticSchema + +from . import schemas + +n1 = "aws.protocoltests.restjson" +_s30 = "smithy.synthetic#originalShapeId" +_s32 = "smithy.api#input" +_s70 = "smithy.api#jsonName" +_s77 = "smithy.api#httpHeader" +_s92 = "smithy.api#output" +_s94 = "smithy.api#timestampFormat" +_s95 = "date-time" +_s107 = "hi" +_s178 = "foo" +_s191 = "epoch-seconds" +_s193 = "http-date" +_s196 = "memberEpochSeconds" +_s199 = "memberHttpDate" +_s200 = "memberDateTime" +_s201 = "defaultFormat" +_s202 = "targetEpochSeconds" +_s203 = "targetHttpDate" +_s204 = "targetDateTime" +_s336 = "stringValue" +_s376 = "data" +_s385 = "bar" +_s417 = "a" +_s418 = "b" +_s435 = "smithy.api#Unit" +_s468 = "X-Foo" +_s475 = "nested" +_s533 = "JsonBlobsInput" +_s534 = "aws.protocoltests.restjson#JsonBlobsInputOutput" +_s535 = "JsonBlobsOutput" +_s536 = "JsonEnumsInput" +_s537 = "aws.protocoltests.restjson#JsonEnumsInputOutput" +_s538 = "fooEnum1" +_s539 = "fooEnum2" +_s540 = "fooEnum3" +_s541 = "fooEnumList" +_s542 = "fooEnumSet" +_s543 = "fooEnumMap" +_s544 = "JsonEnumsOutput" +_s545 = "JsonIntEnumsInput" +_s546 = "aws.protocoltests.restjson#JsonIntEnumsInputOutput" +_s547 = "integerEnum1" +_s548 = "integerEnum2" +_s549 = "integerEnum3" +_s550 = "integerEnumList" +_s551 = "integerEnumSet" +_s552 = "integerEnumMap" +_s553 = "JsonIntEnumsOutput" +_s554 = "JsonListsInput" +_s555 = "aws.protocoltests.restjson#JsonListsInputOutput" +_s556 = "stringList" +_s557 = "stringSet" +_s558 = "integerList" +_s559 = "booleanList" +_s560 = "timestampList" +_s561 = "enumList" +_s562 = "intEnumList" +_s563 = "nestedStringList" +_s564 = "structureList" +_s565 = "myStructureList" +_s566 = "JsonListsOutput" +_s567 = "JsonMapsInput" +_s568 = "aws.protocoltests.restjson#JsonMapsInputOutput" +_s569 = "denseStructMap" +_s570 = "denseNumberMap" +_s571 = "denseBooleanMap" +_s572 = "denseStringMap" +_s573 = "denseSetMap" +_s574 = "JsonMapsOutput" +_s575 = "JsonTimestampsInput" +_s576 = "aws.protocoltests.restjson#JsonTimestampsInputOutput" +_s577 = "normal" +_s578 = "dateTime" +_s579 = "dateTimeOnTarget" +_s580 = "epochSeconds" +_s581 = "epochSecondsOnTarget" +_s582 = "httpDate" +_s583 = "httpDateOnTarget" +_s584 = "JsonTimestampsOutput" +_s585 = "JsonUnionsInput" +_s586 = "aws.protocoltests.restjson#UnionInputOutput" +_s587 = "contents" +_s588 = "JsonUnionsOutput" +_s589 = "MalformedAcceptWithBodyInput" +_s590 = "MalformedAcceptWithBodyOutput" +_s591 = "aws.protocoltests.shared#GreetingStruct" +_s597 = "MalformedContentTypeWithBodyInput" +_s598 = "MalformedContentTypeWithBodyOutput" +_s601 = "MalformedContentTypeWithoutBodyInput" +_s602 = "MalformedContentTypeWithoutBodyOutput" +_s626 = "NoInputAndNoOutputInput" +_s627 = "NoInputAndNoOutputOutput" +_s629 = "NullAndEmptyHeadersClientInput" +_s630 = "aws.protocoltests.restjson#NullAndEmptyHeadersIO" +_s631 = "X-A" +_s632 = "X-B" +_s633 = "c" +_s634 = "X-C" +_s635 = "NullAndEmptyHeadersClientOutput" +_s636 = "NullAndEmptyHeadersServerInput" +_s637 = "NullAndEmptyHeadersServerOutput" +_s644 = "RecursiveShapesInput" +_s645 = "aws.protocoltests.restjson#RecursiveShapesInputOutput" +_s646 = "RecursiveShapesOutput" +_s647 = "ResponseCodeHttpFallbackInput" +_s648 = "aws.protocoltests.restjson#ResponseCodeHttpFallbackInputOutput" +_s649 = "ResponseCodeHttpFallbackOutput" +_s651 = "SimpleScalarPropertiesInput" +_s652 = "aws.protocoltests.restjson#SimpleScalarPropertiesInputOutput" +_s653 = "trueBooleanValue" +_s654 = "falseBooleanValue" +_s655 = "byteValue" +_s656 = "shortValue" +_s657 = "integerValue" +_s658 = "longValue" +_s659 = "floatValue" +_s660 = "doubleValue" +_s661 = "DoubleDribble" +_s662 = "SimpleScalarPropertiesOutput" +_s663 = "SparseJsonListsInput" +_s664 = "aws.protocoltests.restjson#SparseJsonListsInputOutput" +_s665 = "sparseStringList" +_s666 = "sparseShortList" +_s667 = "SparseJsonListsOutput" +_s668 = "SparseJsonMapsInput" +_s669 = "aws.protocoltests.restjson#SparseJsonMapsInputOutput" +_s670 = "sparseStructMap" +_s671 = "sparseNumberMap" +_s672 = "sparseBooleanMap" +_s673 = "sparseStringMap" +_s674 = "sparseSetMap" +_s675 = "SparseJsonMapsOutput" +_s676 = "TestBodyStructureInput" +_s677 = "aws.protocoltests.restjson#TestBodyStructureInputOutput" +_s678 = "testId" +_s679 = "x-amz-test-id" +_s680 = "testConfig" +_s681 = "TestBodyStructureOutput" +_s682 = "TestGetNoInputNoPayloadInput" +_s683 = "TestGetNoInputNoPayloadOutput" +_s684 = "aws.protocoltests.restjson#TestNoPayloadInputOutput" +_s685 = "X-Amz-Test-Id" +_s686 = "TestGetNoPayloadInput" +_s687 = "TestGetNoPayloadOutput" +_s688 = "TestPayloadBlobInput" +_s689 = "aws.protocoltests.restjson#TestPayloadBlobInputOutput" +_s690 = "contentType" +_s691 = "Content-Type" +_s692 = "TestPayloadBlobOutput" +_s693 = "TestPayloadStructureInput" +_s694 = "aws.protocoltests.restjson#TestPayloadStructureInputOutput" +_s695 = "payloadConfig" +_s696 = "TestPayloadStructureOutput" +_s697 = "TestPostNoInputNoPayloadInput" +_s698 = "TestPostNoInputNoPayloadOutput" +_s699 = "TestPostNoPayloadInput" +_s700 = "TestPostNoPayloadOutput" +_s701 = "TimestampFormatHeadersInput" +_s702 = "aws.protocoltests.restjson#TimestampFormatHeadersIO" +_s703 = "X-memberEpochSeconds" +_s704 = "X-memberHttpDate" +_s705 = "X-memberDateTime" +_s706 = "X-defaultFormat" +_s707 = "X-targetEpochSeconds" +_s708 = "X-targetHttpDate" +_s709 = "X-targetDateTime" +_s710 = "TimestampFormatHeadersOutput" +_s711 = "UnitInputAndOutputInput" +_s712 = "UnitInputAndOutputOutput" +_s714 = "smithy.api#http" +_s749 = "JsonBlobs" +_s750 = "JsonEnums" +_s751 = "JsonIntEnums" +_s752 = "JsonLists" +_s753 = "JsonMaps" +_s754 = "JsonTimestamps" +_s755 = "JsonUnions" +_s756 = "MalformedAcceptWithBody" +_s762 = "MalformedContentTypeWithBody" +_s765 = "MalformedContentTypeWithoutBody" +_s790 = "NoInputAndNoOutput" +_s792 = "NullAndEmptyHeadersClient" +_s793 = "NullAndEmptyHeadersServer" +_s805 = "RecursiveShapes" +_s806 = "ResponseCodeHttpFallback" +_s808 = "SimpleScalarProperties" +_s809 = "SparseJsonLists" +_s810 = "SparseJsonMaps" +_s811 = "TestBodyStructure" +_s812 = "TestGetNoInputNoPayload" +_s813 = "TestGetNoPayload" +_s814 = "TestPayloadBlob" +_s815 = "TestPayloadStructure" +_s816 = "TestPostNoInputNoPayload" +_s817 = "TestPostNoPayload" +_s818 = "TimestampFormatHeaders" +_s819 = "UnitInputAndOutput" +_s820 = "RestJson" +_s821 = "aws.api#service" +_s822 = "aws.auth#sigv4" +_s823 = "aws.protocols#restJson1" +_s824 = "RecursiveShapesInputOutputNested1" +_s825 = "RecursiveShapesInputOutputNested2" +_s826 = "recursiveMember" + +JSON_BLOBS_INPUT: StaticSchema = ( + 18, + n1, + _s533, + {_s30: _s534, _s32: None}, + (_s376,), + ((1, 0),), +) + +JSON_BLOBS_OUTPUT: StaticSchema = ( + 18, + n1, + _s535, + {_s30: _s534, _s92: None}, + (_s376,), + ((1, 0),), +) + +JSON_BLOBS: StaticOperationSchema = ( + 23, + n1, + _s749, + {_s714: MappingProxyType({"uri": "/JsonBlobs", "method": "POST"})}, + JSON_BLOBS_INPUT, + JSON_BLOBS_OUTPUT, + (), +) + +JSON_ENUMS_INPUT: StaticSchema = ( + 18, + n1, + _s536, + {_s30: _s537, _s32: None}, + (_s538, _s539, _s540, _s541, _s542, _s543), + ( + (lambda: schemas.FOO_ENUM, 0), + (lambda: schemas.FOO_ENUM, 0), + (lambda: schemas.FOO_ENUM, 0), + (lambda: schemas.FOO_ENUM_LIST, 0), + (lambda: schemas.FOO_ENUM_SET, 0), + (lambda: schemas.FOO_ENUM_MAP, 0), + ), +) + +JSON_ENUMS_OUTPUT: StaticSchema = ( + 18, + n1, + _s544, + {_s30: _s537, _s92: None}, + (_s538, _s539, _s540, _s541, _s542, _s543), + ( + (lambda: schemas.FOO_ENUM, 0), + (lambda: schemas.FOO_ENUM, 0), + (lambda: schemas.FOO_ENUM, 0), + (lambda: schemas.FOO_ENUM_LIST, 0), + (lambda: schemas.FOO_ENUM_SET, 0), + (lambda: schemas.FOO_ENUM_MAP, 0), + ), +) + +JSON_ENUMS: StaticOperationSchema = ( + 23, + n1, + _s750, + {_s714: MappingProxyType({"uri": "/JsonEnums", "method": "PUT"})}, + JSON_ENUMS_INPUT, + JSON_ENUMS_OUTPUT, + (), +) + +JSON_INT_ENUMS_INPUT: StaticSchema = ( + 18, + n1, + _s545, + {_s30: _s546, _s32: None}, + (_s547, _s548, _s549, _s550, _s551, _s552), + ( + (lambda: schemas.INTEGER_ENUM, 0), + (lambda: schemas.INTEGER_ENUM, 0), + (lambda: schemas.INTEGER_ENUM, 0), + (lambda: schemas.INTEGER_ENUM_LIST, 0), + (lambda: schemas.INTEGER_ENUM_SET, 0), + (lambda: schemas.INTEGER_ENUM_MAP, 0), + ), +) + +JSON_INT_ENUMS_OUTPUT: StaticSchema = ( + 18, + n1, + _s553, + {_s30: _s546, _s92: None}, + (_s547, _s548, _s549, _s550, _s551, _s552), + ( + (lambda: schemas.INTEGER_ENUM, 0), + (lambda: schemas.INTEGER_ENUM, 0), + (lambda: schemas.INTEGER_ENUM, 0), + (lambda: schemas.INTEGER_ENUM_LIST, 0), + (lambda: schemas.INTEGER_ENUM_SET, 0), + (lambda: schemas.INTEGER_ENUM_MAP, 0), + ), +) + +JSON_INT_ENUMS: StaticOperationSchema = ( + 23, + n1, + _s751, + {_s714: MappingProxyType({"uri": "/JsonIntEnums", "method": "PUT"})}, + JSON_INT_ENUMS_INPUT, + JSON_INT_ENUMS_OUTPUT, + (), +) + +JSON_LISTS_INPUT: StaticSchema = ( + 18, + n1, + _s554, + {_s30: _s555, _s32: None}, + (_s556, _s557, _s558, _s559, _s560, _s561, _s562, _s563, _s564), + ( + (lambda: schemas.STRING_LIST, 0), + (lambda: schemas.STRING_SET, 0), + (lambda: schemas.INTEGER_LIST, 0), + (lambda: schemas.BOOLEAN_LIST, 0), + (lambda: schemas.TIMESTAMP_LIST, 0), + (lambda: schemas.FOO_ENUM_LIST, 0), + (lambda: schemas.INTEGER_ENUM_LIST, 0), + (lambda: schemas.NESTED_STRING_LIST, 0), + (lambda: schemas.STRUCTURE_LIST, {_s70: _s565}), + ), +) + +JSON_LISTS_OUTPUT: StaticSchema = ( + 18, + n1, + _s566, + {_s30: _s555, _s92: None}, + (_s556, _s557, _s558, _s559, _s560, _s561, _s562, _s563, _s564), + ( + (lambda: schemas.STRING_LIST, 0), + (lambda: schemas.STRING_SET, 0), + (lambda: schemas.INTEGER_LIST, 0), + (lambda: schemas.BOOLEAN_LIST, 0), + (lambda: schemas.TIMESTAMP_LIST, 0), + (lambda: schemas.FOO_ENUM_LIST, 0), + (lambda: schemas.INTEGER_ENUM_LIST, 0), + (lambda: schemas.NESTED_STRING_LIST, 0), + (lambda: schemas.STRUCTURE_LIST, {_s70: _s565}), + ), +) + +JSON_LISTS: StaticOperationSchema = ( + 23, + n1, + _s752, + {_s714: MappingProxyType({"uri": "/JsonLists", "method": "PUT"})}, + JSON_LISTS_INPUT, + JSON_LISTS_OUTPUT, + (), +) + +JSON_MAPS_INPUT: StaticSchema = ( + 18, + n1, + _s567, + {_s30: _s568, _s32: None}, + (_s569, _s570, _s571, _s572, _s573), + ( + (lambda: schemas.DENSE_STRUCT_MAP, 0), + (lambda: schemas.DENSE_NUMBER_MAP, 0), + (lambda: schemas.DENSE_BOOLEAN_MAP, 0), + (lambda: schemas.DENSE_STRING_MAP, 0), + (lambda: schemas.DENSE_SET_MAP, 0), + ), +) + +JSON_MAPS_OUTPUT: StaticSchema = ( + 18, + n1, + _s574, + {_s30: _s568, _s92: None}, + (_s569, _s570, _s571, _s572, _s573), + ( + (lambda: schemas.DENSE_STRUCT_MAP, 0), + (lambda: schemas.DENSE_NUMBER_MAP, 0), + (lambda: schemas.DENSE_BOOLEAN_MAP, 0), + (lambda: schemas.DENSE_STRING_MAP, 0), + (lambda: schemas.DENSE_SET_MAP, 0), + ), +) + +JSON_MAPS: StaticOperationSchema = ( + 23, + n1, + _s753, + {_s714: MappingProxyType({"uri": "/JsonMaps", "method": "POST"})}, + JSON_MAPS_INPUT, + JSON_MAPS_OUTPUT, + (), +) + +JSON_TIMESTAMPS_INPUT: StaticSchema = ( + 18, + n1, + _s575, + {_s30: _s576, _s32: None}, + (_s577, _s578, _s579, _s580, _s581, _s582, _s583), + ( + (4, 0), + (4, {_s94: _s95}), + (lambda: schemas.DATE_TIME, 0), + (4, {_s94: _s191}), + (lambda: schemas.EPOCH_SECONDS, 0), + (4, {_s94: _s193}), + (lambda: schemas.HTTP_DATE, 0), + ), +) + +JSON_TIMESTAMPS_OUTPUT: StaticSchema = ( + 18, + n1, + _s584, + {_s30: _s576, _s92: None}, + (_s577, _s578, _s579, _s580, _s581, _s582, _s583), + ( + (4, 0), + (4, {_s94: _s95}), + (lambda: schemas.DATE_TIME, 0), + (4, {_s94: _s191}), + (lambda: schemas.EPOCH_SECONDS, 0), + (4, {_s94: _s193}), + (lambda: schemas.HTTP_DATE, 0), + ), +) + +JSON_TIMESTAMPS: StaticOperationSchema = ( + 23, + n1, + _s754, + {_s714: MappingProxyType({"uri": "/JsonTimestamps", "method": "POST"})}, + JSON_TIMESTAMPS_INPUT, + JSON_TIMESTAMPS_OUTPUT, + (), +) + +JSON_UNIONS_INPUT: StaticSchema = ( + 18, + n1, + _s585, + {_s30: _s586, _s32: None}, + (_s587,), + ((lambda: schemas.MY_UNION, 0),), +) + +JSON_UNIONS_OUTPUT: StaticSchema = ( + 18, + n1, + _s588, + {_s30: _s586, _s92: None}, + (_s587,), + ((lambda: schemas.MY_UNION, 0),), +) + +JSON_UNIONS: StaticOperationSchema = ( + 23, + n1, + _s755, + {_s714: MappingProxyType({"uri": "/JsonUnions", "method": "PUT"})}, + JSON_UNIONS_INPUT, + JSON_UNIONS_OUTPUT, + (), +) + +MALFORMED_ACCEPT_WITH_BODY_INPUT: StaticSchema = ( + 18, + n1, + _s589, + {_s30: _s435, _s32: None}, +) + +MALFORMED_ACCEPT_WITH_BODY_OUTPUT: StaticSchema = ( + 18, + n1, + _s590, + {_s30: _s591, _s92: None}, + (_s107,), + ((3, 0),), +) + +MALFORMED_ACCEPT_WITH_BODY: StaticOperationSchema = ( + 23, + n1, + _s756, + {_s714: MappingProxyType({"method": "POST", "uri": "/MalformedAcceptWithBody"})}, + MALFORMED_ACCEPT_WITH_BODY_INPUT, + MALFORMED_ACCEPT_WITH_BODY_OUTPUT, + (), +) + +MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT: StaticSchema = ( + 18, + n1, + _s597, + {_s30: _s591, _s32: None}, + (_s107,), + ((3, 0),), +) + +MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT: StaticSchema = ( + 18, + n1, + _s598, + {_s30: _s435, _s92: None}, +) + +MALFORMED_CONTENT_TYPE_WITH_BODY: StaticOperationSchema = ( + 23, + n1, + _s762, + { + _s714: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithBody"} + ) + }, + MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT, + MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT, + (), +) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT: StaticSchema = ( + 18, + n1, + _s601, + {_s30: _s435, _s32: None}, +) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT: StaticSchema = ( + 18, + n1, + _s602, + {_s30: _s435, _s92: None}, +) + +MALFORMED_CONTENT_TYPE_WITHOUT_BODY: StaticOperationSchema = ( + 23, + n1, + _s765, + { + _s714: MappingProxyType( + {"method": "POST", "uri": "/MalformedContentTypeWithoutBody"} + ) + }, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT, + MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT, + (), +) + +NO_INPUT_AND_NO_OUTPUT_INPUT: StaticSchema = ( + 18, + n1, + _s626, + {_s30: _s435, _s32: None}, +) + +NO_INPUT_AND_NO_OUTPUT_OUTPUT: StaticSchema = ( + 18, + n1, + _s627, + {_s30: _s435, _s92: None}, +) + +NO_INPUT_AND_NO_OUTPUT: StaticOperationSchema = ( + 23, + n1, + _s790, + {_s714: MappingProxyType({"uri": "/NoInputAndNoOutput", "method": "POST"})}, + NO_INPUT_AND_NO_OUTPUT_INPUT, + NO_INPUT_AND_NO_OUTPUT_OUTPUT, + (), +) + +NULL_AND_EMPTY_HEADERS_CLIENT_INPUT: StaticSchema = ( + 18, + n1, + _s629, + {_s30: _s630, _s32: None}, + (_s417, _s418, _s633), + ( + (3, {_s77: _s631}), + (3, {_s77: _s632}), + (lambda: schemas.STRING_LIST, {_s77: _s634}), + ), +) + +NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT: StaticSchema = ( + 18, + n1, + _s635, + {_s30: _s630, _s92: None}, + (_s417, _s418, _s633), + ( + (3, {_s77: _s631}), + (3, {_s77: _s632}), + (lambda: schemas.STRING_LIST, {_s77: _s634}), + ), +) + +NULL_AND_EMPTY_HEADERS_CLIENT: StaticOperationSchema = ( + 23, + n1, + _s792, + {_s714: MappingProxyType({"uri": "/NullAndEmptyHeadersClient", "method": "GET"})}, + NULL_AND_EMPTY_HEADERS_CLIENT_INPUT, + NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT, + (), +) + +NULL_AND_EMPTY_HEADERS_SERVER_INPUT: StaticSchema = ( + 18, + n1, + _s636, + {_s30: _s630, _s32: None}, + (_s417, _s418, _s633), + ( + (3, {_s77: _s631}), + (3, {_s77: _s632}), + (lambda: schemas.STRING_LIST, {_s77: _s634}), + ), +) + +NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT: StaticSchema = ( + 18, + n1, + _s637, + {_s30: _s630, _s92: None}, + (_s417, _s418, _s633), + ( + (3, {_s77: _s631}), + (3, {_s77: _s632}), + (lambda: schemas.STRING_LIST, {_s77: _s634}), + ), +) + +NULL_AND_EMPTY_HEADERS_SERVER: StaticOperationSchema = ( + 23, + n1, + _s793, + {_s714: MappingProxyType({"uri": "/NullAndEmptyHeadersServer", "method": "GET"})}, + NULL_AND_EMPTY_HEADERS_SERVER_INPUT, + NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT, + (), +) + +RECURSIVE_SHAPES_INPUT: StaticSchema = ( + 18, + n1, + _s644, + {_s30: _s645, _s32: None}, + (_s475,), + ((lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_SHAPES_OUTPUT: StaticSchema = ( + 18, + n1, + _s646, + {_s30: _s645, _s92: None}, + (_s475,), + ((lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0),), +) + +RECURSIVE_SHAPES: StaticOperationSchema = ( + 23, + n1, + _s805, + {_s714: MappingProxyType({"uri": "/RecursiveShapes", "method": "PUT"})}, + RECURSIVE_SHAPES_INPUT, + RECURSIVE_SHAPES_OUTPUT, + (), +) + +RESPONSE_CODE_HTTP_FALLBACK_INPUT: StaticSchema = ( + 18, + n1, + _s647, + {_s30: _s648, _s32: None}, +) + +RESPONSE_CODE_HTTP_FALLBACK_OUTPUT: StaticSchema = ( + 18, + n1, + _s649, + {_s30: _s648, _s92: None}, +) + +RESPONSE_CODE_HTTP_FALLBACK: StaticOperationSchema = ( + 23, + n1, + _s806, + { + _s714: MappingProxyType( + {"method": "GET", "uri": "/responseCodeHttpFallback", "code": 201} + ) + }, + RESPONSE_CODE_HTTP_FALLBACK_INPUT, + RESPONSE_CODE_HTTP_FALLBACK_OUTPUT, + (), +) + +SIMPLE_SCALAR_PROPERTIES_INPUT: StaticSchema = ( + 18, + n1, + _s651, + {_s30: _s652, _s32: None}, + (_s178, _s336, _s653, _s654, _s655, _s656, _s657, _s658, _s659, _s660), + ( + (3, {_s77: _s468}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_s70: _s661}), + ), +) + +SIMPLE_SCALAR_PROPERTIES_OUTPUT: StaticSchema = ( + 18, + n1, + _s662, + {_s30: _s652, _s92: None}, + (_s178, _s336, _s653, _s654, _s655, _s656, _s657, _s658, _s659, _s660), + ( + (3, {_s77: _s468}), + (3, 0), + (2, 0), + (2, 0), + (5, 0), + (6, 0), + (7, 0), + (8, 0), + (9, 0), + (10, {_s70: _s661}), + ), +) + +SIMPLE_SCALAR_PROPERTIES: StaticOperationSchema = ( + 23, + n1, + _s808, + {_s714: MappingProxyType({"uri": "/SimpleScalarProperties", "method": "PUT"})}, + SIMPLE_SCALAR_PROPERTIES_INPUT, + SIMPLE_SCALAR_PROPERTIES_OUTPUT, + (), +) + +SPARSE_JSON_LISTS_INPUT: StaticSchema = ( + 18, + n1, + _s663, + {_s30: _s664, _s32: None}, + (_s665, _s666), + ((lambda: schemas.SPARSE_STRING_LIST, 0), (lambda: schemas.SPARSE_SHORT_LIST, 0)), +) + +SPARSE_JSON_LISTS_OUTPUT: StaticSchema = ( + 18, + n1, + _s667, + {_s30: _s664, _s92: None}, + (_s665, _s666), + ((lambda: schemas.SPARSE_STRING_LIST, 0), (lambda: schemas.SPARSE_SHORT_LIST, 0)), +) + +SPARSE_JSON_LISTS: StaticOperationSchema = ( + 23, + n1, + _s809, + {_s714: MappingProxyType({"uri": "/SparseJsonLists", "method": "PUT"})}, + SPARSE_JSON_LISTS_INPUT, + SPARSE_JSON_LISTS_OUTPUT, + (), +) + +SPARSE_JSON_MAPS_INPUT: StaticSchema = ( + 18, + n1, + _s668, + {_s30: _s669, _s32: None}, + (_s670, _s671, _s672, _s673, _s674), + ( + (lambda: schemas.SPARSE_STRUCT_MAP, 0), + (lambda: schemas.SPARSE_NUMBER_MAP, 0), + (lambda: schemas.SPARSE_BOOLEAN_MAP, 0), + (lambda: schemas.SPARSE_STRING_MAP, 0), + (lambda: schemas.SPARSE_SET_MAP, 0), + ), +) + +SPARSE_JSON_MAPS_OUTPUT: StaticSchema = ( + 18, + n1, + _s675, + {_s30: _s669, _s92: None}, + (_s670, _s671, _s672, _s673, _s674), + ( + (lambda: schemas.SPARSE_STRUCT_MAP, 0), + (lambda: schemas.SPARSE_NUMBER_MAP, 0), + (lambda: schemas.SPARSE_BOOLEAN_MAP, 0), + (lambda: schemas.SPARSE_STRING_MAP, 0), + (lambda: schemas.SPARSE_SET_MAP, 0), + ), +) + +SPARSE_JSON_MAPS: StaticOperationSchema = ( + 23, + n1, + _s810, + {_s714: MappingProxyType({"uri": "/SparseJsonMaps", "method": "POST"})}, + SPARSE_JSON_MAPS_INPUT, + SPARSE_JSON_MAPS_OUTPUT, + (), +) + +TEST_BODY_STRUCTURE_INPUT: StaticSchema = ( + 18, + n1, + _s676, + {_s30: _s677, _s32: None}, + (_s678, _s680), + ((3, {_s77: _s679}), (lambda: schemas.TEST_CONFIG, 0)), +) + +TEST_BODY_STRUCTURE_OUTPUT: StaticSchema = ( + 18, + n1, + _s681, + {_s30: _s677, _s92: None}, + (_s678, _s680), + ((3, {_s77: _s679}), (lambda: schemas.TEST_CONFIG, 0)), +) + +TEST_BODY_STRUCTURE: StaticOperationSchema = ( + 23, + n1, + _s811, + {_s714: MappingProxyType({"uri": "/body", "method": "POST"})}, + TEST_BODY_STRUCTURE_INPUT, + TEST_BODY_STRUCTURE_OUTPUT, + (), +) + +TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s682, + {_s30: _s435, _s32: None}, +) + +TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s683, + {_s30: _s684, _s92: None}, + (_s678,), + ((3, {_s77: _s685}),), +) + +TEST_GET_NO_INPUT_NO_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s812, + {_s714: MappingProxyType({"uri": "/no_input_no_payload", "method": "GET"})}, + TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT, + TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT, + (), +) + +TEST_GET_NO_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s686, + {_s30: _s684, _s32: None}, + (_s678,), + ((3, {_s77: _s685}),), +) + +TEST_GET_NO_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s687, + {_s30: _s684, _s92: None}, + (_s678,), + ((3, {_s77: _s685}),), +) + +TEST_GET_NO_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s813, + {_s714: MappingProxyType({"uri": "/no_payload", "method": "GET"})}, + TEST_GET_NO_PAYLOAD_INPUT, + TEST_GET_NO_PAYLOAD_OUTPUT, + (), +) + +TEST_PAYLOAD_BLOB_INPUT: StaticSchema = ( + 18, + n1, + _s688, + {_s30: _s689, _s32: None}, + (_s690, _s376), + ((3, {_s77: _s691}), (1, 16)), +) + +TEST_PAYLOAD_BLOB_OUTPUT: StaticSchema = ( + 18, + n1, + _s692, + {_s30: _s689, _s92: None}, + (_s690, _s376), + ((3, {_s77: _s691}), (1, 16)), +) + +TEST_PAYLOAD_BLOB: StaticOperationSchema = ( + 23, + n1, + _s814, + {_s714: MappingProxyType({"uri": "/blob_payload", "method": "POST"})}, + TEST_PAYLOAD_BLOB_INPUT, + TEST_PAYLOAD_BLOB_OUTPUT, + (), +) + +TEST_PAYLOAD_STRUCTURE_INPUT: StaticSchema = ( + 18, + n1, + _s693, + {_s30: _s694, _s32: None}, + (_s678, _s695), + ((3, {_s77: _s679}), (lambda: schemas.PAYLOAD_CONFIG, 16)), +) + +TEST_PAYLOAD_STRUCTURE_OUTPUT: StaticSchema = ( + 18, + n1, + _s696, + {_s30: _s694, _s92: None}, + (_s678, _s695), + ((3, {_s77: _s679}), (lambda: schemas.PAYLOAD_CONFIG, 16)), +) + +TEST_PAYLOAD_STRUCTURE: StaticOperationSchema = ( + 23, + n1, + _s815, + {_s714: MappingProxyType({"uri": "/payload", "method": "POST"})}, + TEST_PAYLOAD_STRUCTURE_INPUT, + TEST_PAYLOAD_STRUCTURE_OUTPUT, + (), +) + +TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s697, + {_s30: _s435, _s32: None}, +) + +TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s698, + {_s30: _s684, _s92: None}, + (_s678,), + ((3, {_s77: _s685}),), +) + +TEST_POST_NO_INPUT_NO_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s816, + {_s714: MappingProxyType({"uri": "/no_input_no_payload", "method": "POST"})}, + TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT, + TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT, + (), +) + +TEST_POST_NO_PAYLOAD_INPUT: StaticSchema = ( + 18, + n1, + _s699, + {_s30: _s684, _s32: None}, + (_s678,), + ((3, {_s77: _s685}),), +) + +TEST_POST_NO_PAYLOAD_OUTPUT: StaticSchema = ( + 18, + n1, + _s700, + {_s30: _s684, _s92: None}, + (_s678,), + ((3, {_s77: _s685}),), +) + +TEST_POST_NO_PAYLOAD: StaticOperationSchema = ( + 23, + n1, + _s817, + {_s714: MappingProxyType({"uri": "/no_payload", "method": "POST"})}, + TEST_POST_NO_PAYLOAD_INPUT, + TEST_POST_NO_PAYLOAD_OUTPUT, + (), +) + +TIMESTAMP_FORMAT_HEADERS_INPUT: StaticSchema = ( + 18, + n1, + _s701, + {_s30: _s702, _s32: None}, + (_s196, _s199, _s200, _s201, _s202, _s203, _s204), + ( + (4, {_s77: _s703, _s94: _s191}), + (4, {_s77: _s704, _s94: _s193}), + (4, {_s77: _s705, _s94: _s95}), + (4, {_s77: _s706}), + (lambda: schemas.EPOCH_SECONDS, {_s77: _s707}), + (lambda: schemas.HTTP_DATE, {_s77: _s708}), + (lambda: schemas.DATE_TIME, {_s77: _s709}), + ), +) + +TIMESTAMP_FORMAT_HEADERS_OUTPUT: StaticSchema = ( + 18, + n1, + _s710, + {_s30: _s702, _s92: None}, + (_s196, _s199, _s200, _s201, _s202, _s203, _s204), + ( + (4, {_s77: _s703, _s94: _s191}), + (4, {_s77: _s704, _s94: _s193}), + (4, {_s77: _s705, _s94: _s95}), + (4, {_s77: _s706}), + (lambda: schemas.EPOCH_SECONDS, {_s77: _s707}), + (lambda: schemas.HTTP_DATE, {_s77: _s708}), + (lambda: schemas.DATE_TIME, {_s77: _s709}), + ), +) + +TIMESTAMP_FORMAT_HEADERS: StaticOperationSchema = ( + 23, + n1, + _s818, + {_s714: MappingProxyType({"uri": "/TimestampFormatHeaders", "method": "POST"})}, + TIMESTAMP_FORMAT_HEADERS_INPUT, + TIMESTAMP_FORMAT_HEADERS_OUTPUT, + (), +) + +UNIT_INPUT_AND_OUTPUT_INPUT: StaticSchema = ( + 18, + n1, + _s711, + {_s30: _s435, _s32: None}, +) + +UNIT_INPUT_AND_OUTPUT_OUTPUT: StaticSchema = ( + 18, + n1, + _s712, + {_s30: _s435, _s92: None}, +) + +UNIT_INPUT_AND_OUTPUT: StaticOperationSchema = ( + 23, + n1, + _s819, + {_s714: MappingProxyType({"uri": "/UnitInputAndOutput", "method": "POST"})}, + UNIT_INPUT_AND_OUTPUT_INPUT, + UNIT_INPUT_AND_OUTPUT_OUTPUT, + (), +) + +REST_JSON: StaticSchema = ( + 21, + n1, + _s820, + { + _s821: MappingProxyType({"sdkId": "Rest Json Protocol"}), + _s822: MappingProxyType({"name": "restjson"}), + _s823: None, + }, +) + +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1: StaticSchema = ( + 18, + n1, + _s824, + 0, + (_s178, _s475), + ((3, 0), (lambda: RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2, 0)), +) + +RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2: StaticSchema = ( + 18, + n1, + _s825, + 0, + (_s385, _s826), + ((3, 0), (RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1, 0)), +) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/aio/__init__.py b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/__init__.py new file mode 100644 index 000000000..94cdda50a --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/__init__.py @@ -0,0 +1,19 @@ +from importlib import import_module +from typing import TYPE_CHECKING, Any + +if TYPE_CHECKING: + from .client import AsyncRestJsonProtocolClient + from .config import AsyncRestJsonProtocolConfig + +__all__ = ["AsyncRestJsonProtocolClient", "AsyncRestJsonProtocolConfig"] + +_EXPORTS = { + "AsyncRestJsonProtocolClient": ".client", + "AsyncRestJsonProtocolConfig": ".config", +} + + +def __getattr__(name: str) -> Any: + if name in _EXPORTS: + return getattr(import_module(_EXPORTS[name], __name__), name) + raise AttributeError(f"module {__name__!r} has no attribute {name!r}") diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/aio/client.py b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/client.py new file mode 100644 index 000000000..052017b44 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/client.py @@ -0,0 +1,3717 @@ +from __future__ import annotations + +from typing import Unpack, cast, overload + +from smithy_aws_core.aio.identity.chain import AsyncIdentityChain +from smithy_aws_core.config.types import ConfigSource +from smithy_aws_core.identity.components import AWSCredentialsIdentity +from smithy_core.aio.client import AsyncClient +from smithy_http.aio.interfaces import AsyncHTTPClient +from smithy_http.plugins import user_agent_plugin + +from restjson_client import models +from restjson_client.aio.config import AsyncRestJsonProtocolConfig, Plugin +from restjson_client.aio.user_agent import aws_user_agent_plugin + + +class AsyncRestJsonProtocolClient(AsyncClient[AsyncRestJsonProtocolConfig]): + "Client for RestJson." + + _client_plugins = (aws_user_agent_plugin, user_agent_plugin) + + @overload + async def all_query_string_types( + self, + request: models.AllQueryStringTypesInput | models.AllQueryStringTypesInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.AllQueryStringTypesOutput: ... + + @overload + async def all_query_string_types( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.AllQueryStringTypesInputDict], + ) -> models.AllQueryStringTypesOutput: + """ + This example uses all query string types. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def all_query_string_types( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.AllQueryStringTypesOutput: + return await self._invoke( + self._select_input(models.ALL_QUERY_STRING_TYPES, args, kwargs), + models.ALL_QUERY_STRING_TYPES, + [], + plugins, + ) + + @overload + async def constant_and_variable_query_string( + self, + request: models.ConstantAndVariableQueryStringInput + | models.ConstantAndVariableQueryStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ConstantAndVariableQueryStringOutput: ... + + @overload + async def constant_and_variable_query_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ConstantAndVariableQueryStringInputDict], + ) -> models.ConstantAndVariableQueryStringOutput: + """ + This example uses fixed query string params and variable query string + params. + The fixed query string parameters and variable parameters must both be + serialized (implementations may need to merge them together). + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def constant_and_variable_query_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ConstantAndVariableQueryStringOutput: + return await self._invoke( + self._select_input(models.CONSTANT_AND_VARIABLE_QUERY_STRING, args, kwargs), + models.CONSTANT_AND_VARIABLE_QUERY_STRING, + [], + plugins, + ) + + @overload + async def constant_query_string( + self, + request: models.ConstantQueryStringInput | models.ConstantQueryStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ConstantQueryStringOutput: ... + + @overload + async def constant_query_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ConstantQueryStringInputDict], + ) -> models.ConstantQueryStringOutput: + """ + This example uses a constant query string parameters and a label. + This simply tests that labels and query string parameters are + compatible. The fixed query string parameter named "hello" should + in no way conflict with the label, `{hello}`. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def constant_query_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ConstantQueryStringOutput: + return await self._invoke( + self._select_input(models.CONSTANT_QUERY_STRING, args, kwargs), + models.CONSTANT_QUERY_STRING, + [], + plugins, + ) + + @overload + async def content_type_parameters( + self, + request: models.ContentTypeParametersInput + | models.ContentTypeParametersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ContentTypeParametersOutput: ... + + @overload + async def content_type_parameters( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ContentTypeParametersInputDict], + ) -> models.ContentTypeParametersOutput: + """ + The example tests how servers must support requests + containing a `Content-Type` header with parameters. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def content_type_parameters( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ContentTypeParametersOutput: + return await self._invoke( + self._select_input(models.CONTENT_TYPE_PARAMETERS, args, kwargs), + models.CONTENT_TYPE_PARAMETERS, + [], + plugins, + ) + + @overload + async def datetime_offsets( + self, + request: models.DatetimeOffsetsInput | models.DatetimeOffsetsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DatetimeOffsetsOutput: ... + + @overload + async def datetime_offsets( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DatetimeOffsetsInputDict], + ) -> models.DatetimeOffsetsOutput: + """ + Invokes the DatetimeOffsets operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def datetime_offsets( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DatetimeOffsetsOutput: + return await self._invoke( + self._select_input(models.DATETIME_OFFSETS, args, kwargs), + models.DATETIME_OFFSETS, + [], + plugins, + ) + + @overload + async def document_type( + self, + request: models.DocumentTypeInput | models.DocumentTypeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DocumentTypeOutput: ... + + @overload + async def document_type( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DocumentTypeInputDict], + ) -> models.DocumentTypeOutput: + """ + This example serializes a document as part of the payload. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def document_type( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DocumentTypeOutput: + return await self._invoke( + self._select_input(models.DOCUMENT_TYPE, args, kwargs), + models.DOCUMENT_TYPE, + [], + plugins, + ) + + @overload + async def document_type_as_map_value( + self, + request: models.DocumentTypeAsMapValueInput + | models.DocumentTypeAsMapValueInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DocumentTypeAsMapValueOutput: ... + + @overload + async def document_type_as_map_value( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DocumentTypeAsMapValueInputDict], + ) -> models.DocumentTypeAsMapValueOutput: + """ + This example serializes documents as the value of maps. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def document_type_as_map_value( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DocumentTypeAsMapValueOutput: + return await self._invoke( + self._select_input(models.DOCUMENT_TYPE_AS_MAP_VALUE, args, kwargs), + models.DOCUMENT_TYPE_AS_MAP_VALUE, + [], + plugins, + ) + + @overload + async def document_type_as_payload( + self, + request: models.DocumentTypeAsPayloadInput + | models.DocumentTypeAsPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DocumentTypeAsPayloadOutput: ... + + @overload + async def document_type_as_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DocumentTypeAsPayloadInputDict], + ) -> models.DocumentTypeAsPayloadOutput: + """ + This example serializes a document as the entire HTTP payload. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def document_type_as_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DocumentTypeAsPayloadOutput: + return await self._invoke( + self._select_input(models.DOCUMENT_TYPE_AS_PAYLOAD, args, kwargs), + models.DOCUMENT_TYPE_AS_PAYLOAD, + [], + plugins, + ) + + @overload + async def empty_input_and_empty_output( + self, + request: models.EmptyInputAndEmptyOutputInput + | models.EmptyInputAndEmptyOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.EmptyInputAndEmptyOutputOutput: ... + + @overload + async def empty_input_and_empty_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.EmptyInputAndEmptyOutputInputDict], + ) -> models.EmptyInputAndEmptyOutputOutput: + """ + The example tests how requests and responses are serialized when there's + no request or response payload because the operation has an empty input + and empty output structure that reuses the same shape. While this should + be rare, code generators must support this. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def empty_input_and_empty_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.EmptyInputAndEmptyOutputOutput: + return await self._invoke( + self._select_input(models.EMPTY_INPUT_AND_EMPTY_OUTPUT, args, kwargs), + models.EMPTY_INPUT_AND_EMPTY_OUTPUT, + [], + plugins, + ) + + @overload + async def endpoint_operation( + self, + request: models.EndpointOperationInput | models.EndpointOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.EndpointOperationOutput: ... + + @overload + async def endpoint_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.EndpointOperationInputDict], + ) -> models.EndpointOperationOutput: + """ + Invokes the EndpointOperation operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def endpoint_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.EndpointOperationOutput: + return await self._invoke( + self._select_input(models.ENDPOINT_OPERATION, args, kwargs), + models.ENDPOINT_OPERATION, + [], + plugins, + ) + + @overload + async def endpoint_with_host_label_operation( + self, + request: models.EndpointWithHostLabelOperationInput + | models.EndpointWithHostLabelOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.EndpointWithHostLabelOperationOutput: ... + + @overload + async def endpoint_with_host_label_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.EndpointWithHostLabelOperationInputDict], + ) -> models.EndpointWithHostLabelOperationOutput: + """ + Invokes the EndpointWithHostLabelOperation operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def endpoint_with_host_label_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.EndpointWithHostLabelOperationOutput: + return await self._invoke( + self._select_input(models.ENDPOINT_WITH_HOST_LABEL_OPERATION, args, kwargs), + models.ENDPOINT_WITH_HOST_LABEL_OPERATION, + [], + plugins, + ) + + @overload + async def fractional_seconds( + self, + request: models.FractionalSecondsInput | models.FractionalSecondsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.FractionalSecondsOutput: ... + + @overload + async def fractional_seconds( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.FractionalSecondsInputDict], + ) -> models.FractionalSecondsOutput: + """ + Invokes the FractionalSeconds operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def fractional_seconds( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.FractionalSecondsOutput: + return await self._invoke( + self._select_input(models.FRACTIONAL_SECONDS, args, kwargs), + models.FRACTIONAL_SECONDS, + [], + plugins, + ) + + @overload + async def greeting_with_errors( + self, + request: models.GreetingWithErrorsInput | models.GreetingWithErrorsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.GreetingWithErrorsOutput: ... + + @overload + async def greeting_with_errors( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.GreetingWithErrorsInputDict], + ) -> models.GreetingWithErrorsOutput: + """ + This operation has four possible return values: + + 1. A successful response in the form of GreetingWithErrorsOutput + 2. An InvalidGreeting error. + 3. A BadRequest error. + 4. A FooError. + + Implementations must be able to successfully take a response and + properly (de)serialize successful and error responses based on the + the presence of the + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def greeting_with_errors( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.GreetingWithErrorsOutput: + return await self._invoke( + self._select_input(models.GREETING_WITH_ERRORS, args, kwargs), + models.GREETING_WITH_ERRORS, + [], + plugins, + ) + + @overload + async def host_with_path_operation( + self, + request: models.HostWithPathOperationInput + | models.HostWithPathOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HostWithPathOperationOutput: ... + + @overload + async def host_with_path_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HostWithPathOperationInputDict], + ) -> models.HostWithPathOperationOutput: + """ + Invokes the HostWithPathOperation operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def host_with_path_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HostWithPathOperationOutput: + return await self._invoke( + self._select_input(models.HOST_WITH_PATH_OPERATION, args, kwargs), + models.HOST_WITH_PATH_OPERATION, + [], + plugins, + ) + + @overload + async def http_checksum_required( + self, + request: models.HttpChecksumRequiredInput + | models.HttpChecksumRequiredInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpChecksumRequiredOutput: ... + + @overload + async def http_checksum_required( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpChecksumRequiredInputDict], + ) -> models.HttpChecksumRequiredOutput: + """ + This example tests httpChecksumRequired trait + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_checksum_required( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpChecksumRequiredOutput: + return await self._invoke( + self._select_input(models.HTTP_CHECKSUM_REQUIRED, args, kwargs), + models.HTTP_CHECKSUM_REQUIRED, + [], + plugins, + ) + + @overload + async def http_empty_prefix_headers( + self, + request: models.HttpEmptyPrefixHeadersInput + | models.HttpEmptyPrefixHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpEmptyPrefixHeadersOutput: ... + + @overload + async def http_empty_prefix_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpEmptyPrefixHeadersInputDict], + ) -> models.HttpEmptyPrefixHeadersOutput: + """ + Clients that perform this test extract all headers from the response. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_empty_prefix_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpEmptyPrefixHeadersOutput: + return await self._invoke( + self._select_input(models.HTTP_EMPTY_PREFIX_HEADERS, args, kwargs), + models.HTTP_EMPTY_PREFIX_HEADERS, + [], + plugins, + ) + + @overload + async def http_enum_payload( + self, + request: models.HttpEnumPayloadInput | models.HttpEnumPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpEnumPayloadOutput: ... + + @overload + async def http_enum_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpEnumPayloadInputDict], + ) -> models.HttpEnumPayloadOutput: + """ + Invokes the HttpEnumPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_enum_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpEnumPayloadOutput: + return await self._invoke( + self._select_input(models.HTTP_ENUM_PAYLOAD, args, kwargs), + models.HTTP_ENUM_PAYLOAD, + [], + plugins, + ) + + @overload + async def http_payload_traits( + self, + request: models.HttpPayloadTraitsInput | models.HttpPayloadTraitsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadTraitsOutput: ... + + @overload + async def http_payload_traits( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadTraitsInputDict], + ) -> models.HttpPayloadTraitsOutput: + """ + This example serializes a blob shape in the payload. + + In this example, no JSON document is synthesized because the payload is + not a structure or a union type. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_payload_traits( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadTraitsOutput: + return await self._invoke( + self._select_input(models.HTTP_PAYLOAD_TRAITS, args, kwargs), + models.HTTP_PAYLOAD_TRAITS, + [], + plugins, + ) + + @overload + async def http_payload_traits_with_media_type( + self, + request: models.HttpPayloadTraitsWithMediaTypeInput + | models.HttpPayloadTraitsWithMediaTypeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadTraitsWithMediaTypeOutput: ... + + @overload + async def http_payload_traits_with_media_type( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadTraitsWithMediaTypeInputDict], + ) -> models.HttpPayloadTraitsWithMediaTypeOutput: + """ + This example uses a `@mediaType` trait on the payload to force a custom + content-type to be serialized. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_payload_traits_with_media_type( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadTraitsWithMediaTypeOutput: + return await self._invoke( + self._select_input( + models.HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, args, kwargs + ), + models.HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, + [], + plugins, + ) + + @overload + async def http_payload_with_structure( + self, + request: models.HttpPayloadWithStructureInput + | models.HttpPayloadWithStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadWithStructureOutput: ... + + @overload + async def http_payload_with_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadWithStructureInputDict], + ) -> models.HttpPayloadWithStructureOutput: + """ + This example serializes a structure in the payload. + + Note that serializing a structure changes the wrapper element name + to match the targeted structure. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_payload_with_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadWithStructureOutput: + return await self._invoke( + self._select_input(models.HTTP_PAYLOAD_WITH_STRUCTURE, args, kwargs), + models.HTTP_PAYLOAD_WITH_STRUCTURE, + [], + plugins, + ) + + @overload + async def http_payload_with_union( + self, + request: models.HttpPayloadWithUnionInput + | models.HttpPayloadWithUnionInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadWithUnionOutput: ... + + @overload + async def http_payload_with_union( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadWithUnionInputDict], + ) -> models.HttpPayloadWithUnionOutput: + """ + This example serializes a union in the payload. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_payload_with_union( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadWithUnionOutput: + return await self._invoke( + self._select_input(models.HTTP_PAYLOAD_WITH_UNION, args, kwargs), + models.HTTP_PAYLOAD_WITH_UNION, + [], + plugins, + ) + + @overload + async def http_prefix_headers( + self, + request: models.HttpPrefixHeadersInput | models.HttpPrefixHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPrefixHeadersOutput: ... + + @overload + async def http_prefix_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPrefixHeadersInputDict], + ) -> models.HttpPrefixHeadersOutput: + """ + This examples adds headers to the input of a request and response by + prefix. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_prefix_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPrefixHeadersOutput: + return await self._invoke( + self._select_input(models.HTTP_PREFIX_HEADERS, args, kwargs), + models.HTTP_PREFIX_HEADERS, + [], + plugins, + ) + + @overload + async def http_prefix_headers_in_response( + self, + request: models.HttpPrefixHeadersInResponseInput + | models.HttpPrefixHeadersInResponseInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPrefixHeadersInResponseOutput: ... + + @overload + async def http_prefix_headers_in_response( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPrefixHeadersInResponseInputDict], + ) -> models.HttpPrefixHeadersInResponseOutput: + """ + Clients that perform this test extract all headers from the response. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_prefix_headers_in_response( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPrefixHeadersInResponseOutput: + return await self._invoke( + self._select_input(models.HTTP_PREFIX_HEADERS_IN_RESPONSE, args, kwargs), + models.HTTP_PREFIX_HEADERS_IN_RESPONSE, + [], + plugins, + ) + + @overload + async def http_query_params_only_operation( + self, + request: models.HttpQueryParamsOnlyOperationInput + | models.HttpQueryParamsOnlyOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpQueryParamsOnlyOperationOutput: ... + + @overload + async def http_query_params_only_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpQueryParamsOnlyOperationInputDict], + ) -> models.HttpQueryParamsOnlyOperationOutput: + """ + This example tests httpQueryParams when no other query parameters exist. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_query_params_only_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpQueryParamsOnlyOperationOutput: + return await self._invoke( + self._select_input(models.HTTP_QUERY_PARAMS_ONLY_OPERATION, args, kwargs), + models.HTTP_QUERY_PARAMS_ONLY_OPERATION, + [], + plugins, + ) + + @overload + async def http_request_with_float_labels( + self, + request: models.HttpRequestWithFloatLabelsInput + | models.HttpRequestWithFloatLabelsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithFloatLabelsOutput: ... + + @overload + async def http_request_with_float_labels( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithFloatLabelsInputDict], + ) -> models.HttpRequestWithFloatLabelsOutput: + """ + Invokes the HttpRequestWithFloatLabels operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_request_with_float_labels( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithFloatLabelsOutput: + return await self._invoke( + self._select_input(models.HTTP_REQUEST_WITH_FLOAT_LABELS, args, kwargs), + models.HTTP_REQUEST_WITH_FLOAT_LABELS, + [], + plugins, + ) + + @overload + async def http_request_with_greedy_label_in_path( + self, + request: models.HttpRequestWithGreedyLabelInPathInput + | models.HttpRequestWithGreedyLabelInPathInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithGreedyLabelInPathOutput: ... + + @overload + async def http_request_with_greedy_label_in_path( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithGreedyLabelInPathInputDict], + ) -> models.HttpRequestWithGreedyLabelInPathOutput: + """ + Invokes the HttpRequestWithGreedyLabelInPath operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_request_with_greedy_label_in_path( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithGreedyLabelInPathOutput: + return await self._invoke( + self._select_input( + models.HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, args, kwargs + ), + models.HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, + [], + plugins, + ) + + @overload + async def http_request_with_labels( + self, + request: models.HttpRequestWithLabelsInput + | models.HttpRequestWithLabelsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithLabelsOutput: ... + + @overload + async def http_request_with_labels( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithLabelsInputDict], + ) -> models.HttpRequestWithLabelsOutput: + """ + The example tests how requests are serialized when there's no input + payload but there are HTTP labels. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_request_with_labels( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithLabelsOutput: + return await self._invoke( + self._select_input(models.HTTP_REQUEST_WITH_LABELS, args, kwargs), + models.HTTP_REQUEST_WITH_LABELS, + [], + plugins, + ) + + @overload + async def http_request_with_labels_and_timestamp_format( + self, + request: models.HttpRequestWithLabelsAndTimestampFormatInput + | models.HttpRequestWithLabelsAndTimestampFormatInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithLabelsAndTimestampFormatOutput: ... + + @overload + async def http_request_with_labels_and_timestamp_format( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithLabelsAndTimestampFormatInputDict], + ) -> models.HttpRequestWithLabelsAndTimestampFormatOutput: + """ + The example tests how requests serialize different timestamp formats in + the + URI path. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_request_with_labels_and_timestamp_format( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithLabelsAndTimestampFormatOutput: + return await self._invoke( + self._select_input( + models.HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, args, kwargs + ), + models.HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, + [], + plugins, + ) + + @overload + async def http_request_with_regex_literal( + self, + request: models.HttpRequestWithRegexLiteralInput + | models.HttpRequestWithRegexLiteralInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithRegexLiteralOutput: ... + + @overload + async def http_request_with_regex_literal( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithRegexLiteralInputDict], + ) -> models.HttpRequestWithRegexLiteralOutput: + """ + Invokes the HttpRequestWithRegexLiteral operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_request_with_regex_literal( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithRegexLiteralOutput: + return await self._invoke( + self._select_input(models.HTTP_REQUEST_WITH_REGEX_LITERAL, args, kwargs), + models.HTTP_REQUEST_WITH_REGEX_LITERAL, + [], + plugins, + ) + + @overload + async def http_response_code( + self, + request: models.HttpResponseCodeInput | models.HttpResponseCodeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpResponseCodeOutput: ... + + @overload + async def http_response_code( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpResponseCodeInputDict], + ) -> models.HttpResponseCodeOutput: + """ + Invokes the HttpResponseCode operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_response_code( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpResponseCodeOutput: + return await self._invoke( + self._select_input(models.HTTP_RESPONSE_CODE, args, kwargs), + models.HTTP_RESPONSE_CODE, + [], + plugins, + ) + + @overload + async def http_string_payload( + self, + request: models.HttpStringPayloadInput | models.HttpStringPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpStringPayloadOutput: ... + + @overload + async def http_string_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpStringPayloadInputDict], + ) -> models.HttpStringPayloadOutput: + """ + Invokes the HttpStringPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def http_string_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpStringPayloadOutput: + return await self._invoke( + self._select_input(models.HTTP_STRING_PAYLOAD, args, kwargs), + models.HTTP_STRING_PAYLOAD, + [], + plugins, + ) + + @overload + async def ignore_query_params_in_response( + self, + request: models.IgnoreQueryParamsInResponseInput + | models.IgnoreQueryParamsInResponseInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.IgnoreQueryParamsInResponseOutput: ... + + @overload + async def ignore_query_params_in_response( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.IgnoreQueryParamsInResponseInputDict], + ) -> models.IgnoreQueryParamsInResponseOutput: + """ + This example ensures that query string bound request parameters are + serialized in the body of responses if the structure is used in both + the request and response. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def ignore_query_params_in_response( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.IgnoreQueryParamsInResponseOutput: + return await self._invoke( + self._select_input(models.IGNORE_QUERY_PARAMS_IN_RESPONSE, args, kwargs), + models.IGNORE_QUERY_PARAMS_IN_RESPONSE, + [], + plugins, + ) + + @overload + async def input_and_output_with_headers( + self, + request: models.InputAndOutputWithHeadersInput + | models.InputAndOutputWithHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.InputAndOutputWithHeadersOutput: ... + + @overload + async def input_and_output_with_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.InputAndOutputWithHeadersInputDict], + ) -> models.InputAndOutputWithHeadersOutput: + """ + The example tests how requests and responses are serialized when there + is + no input or output payload but there are HTTP header bindings. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def input_and_output_with_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.InputAndOutputWithHeadersOutput: + return await self._invoke( + self._select_input(models.INPUT_AND_OUTPUT_WITH_HEADERS, args, kwargs), + models.INPUT_AND_OUTPUT_WITH_HEADERS, + [], + plugins, + ) + + @overload + async def json_blobs( + self, + request: models.JsonBlobsInput | models.JsonBlobsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonBlobsOutput: ... + + @overload + async def json_blobs( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonBlobsInputDict], + ) -> models.JsonBlobsOutput: + """ + Blobs are base64 encoded + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def json_blobs( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonBlobsOutput: + return await self._invoke( + self._select_input(models.JSON_BLOBS, args, kwargs), + models.JSON_BLOBS, + [], + plugins, + ) + + @overload + async def json_enums( + self, + request: models.JsonEnumsInput | models.JsonEnumsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonEnumsOutput: ... + + @overload + async def json_enums( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonEnumsInputDict], + ) -> models.JsonEnumsOutput: + """ + This example serializes enums as top level properties, in lists, sets, + and maps. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def json_enums( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonEnumsOutput: + return await self._invoke( + self._select_input(models.JSON_ENUMS, args, kwargs), + models.JSON_ENUMS, + [], + plugins, + ) + + @overload + async def json_int_enums( + self, + request: models.JsonIntEnumsInput | models.JsonIntEnumsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonIntEnumsOutput: ... + + @overload + async def json_int_enums( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonIntEnumsInputDict], + ) -> models.JsonIntEnumsOutput: + """ + This example serializes intEnums as top level properties, in lists, + sets, and maps. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def json_int_enums( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonIntEnumsOutput: + return await self._invoke( + self._select_input(models.JSON_INT_ENUMS, args, kwargs), + models.JSON_INT_ENUMS, + [], + plugins, + ) + + @overload + async def json_lists( + self, + request: models.JsonListsInput | models.JsonListsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonListsOutput: ... + + @overload + async def json_lists( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonListsInputDict], + ) -> models.JsonListsOutput: + """ + This test case serializes JSON lists for the following cases for both + input and output: + + 1. Normal JSON lists. + 2. Normal JSON sets. + 3. JSON lists of lists. + 4. Lists of structures. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def json_lists( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonListsOutput: + return await self._invoke( + self._select_input(models.JSON_LISTS, args, kwargs), + models.JSON_LISTS, + [], + plugins, + ) + + @overload + async def json_maps( + self, + request: models.JsonMapsInput | models.JsonMapsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonMapsOutput: ... + + @overload + async def json_maps( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonMapsInputDict], + ) -> models.JsonMapsOutput: + """ + The example tests basic map serialization. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def json_maps( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonMapsOutput: + return await self._invoke( + self._select_input(models.JSON_MAPS, args, kwargs), + models.JSON_MAPS, + [], + plugins, + ) + + @overload + async def json_timestamps( + self, + request: models.JsonTimestampsInput | models.JsonTimestampsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonTimestampsOutput: ... + + @overload + async def json_timestamps( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonTimestampsInputDict], + ) -> models.JsonTimestampsOutput: + """ + This tests how timestamps are serialized, including using the + default format of date-time and various @timestampFormat trait + values. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def json_timestamps( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonTimestampsOutput: + return await self._invoke( + self._select_input(models.JSON_TIMESTAMPS, args, kwargs), + models.JSON_TIMESTAMPS, + [], + plugins, + ) + + @overload + async def json_unions( + self, + request: models.JsonUnionsInput | models.JsonUnionsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonUnionsOutput: ... + + @overload + async def json_unions( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonUnionsInputDict], + ) -> models.JsonUnionsOutput: + """ + This operation uses unions for inputs and outputs. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def json_unions( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonUnionsOutput: + return await self._invoke( + self._select_input(models.JSON_UNIONS, args, kwargs), + models.JSON_UNIONS, + [], + plugins, + ) + + @overload + async def malformed_accept_with_body( + self, + request: models.MalformedAcceptWithBodyInput + | models.MalformedAcceptWithBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedAcceptWithBodyOutput: ... + + @overload + async def malformed_accept_with_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedAcceptWithBodyInputDict], + ) -> models.MalformedAcceptWithBodyOutput: + """ + Invokes the MalformedAcceptWithBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_accept_with_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedAcceptWithBodyOutput: + return await self._invoke( + self._select_input(models.MALFORMED_ACCEPT_WITH_BODY, args, kwargs), + models.MALFORMED_ACCEPT_WITH_BODY, + [], + plugins, + ) + + @overload + async def malformed_accept_with_generic_string( + self, + request: models.MalformedAcceptWithGenericStringInput + | models.MalformedAcceptWithGenericStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedAcceptWithGenericStringOutput: ... + + @overload + async def malformed_accept_with_generic_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedAcceptWithGenericStringInputDict], + ) -> models.MalformedAcceptWithGenericStringOutput: + """ + Invokes the MalformedAcceptWithGenericString operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_accept_with_generic_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedAcceptWithGenericStringOutput: + return await self._invoke( + self._select_input( + models.MALFORMED_ACCEPT_WITH_GENERIC_STRING, args, kwargs + ), + models.MALFORMED_ACCEPT_WITH_GENERIC_STRING, + [], + plugins, + ) + + @overload + async def malformed_accept_with_payload( + self, + request: models.MalformedAcceptWithPayloadInput + | models.MalformedAcceptWithPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedAcceptWithPayloadOutput: ... + + @overload + async def malformed_accept_with_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedAcceptWithPayloadInputDict], + ) -> models.MalformedAcceptWithPayloadOutput: + """ + Invokes the MalformedAcceptWithPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_accept_with_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedAcceptWithPayloadOutput: + return await self._invoke( + self._select_input(models.MALFORMED_ACCEPT_WITH_PAYLOAD, args, kwargs), + models.MALFORMED_ACCEPT_WITH_PAYLOAD, + [], + plugins, + ) + + @overload + async def malformed_blob( + self, + request: models.MalformedBlobInput | models.MalformedBlobInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedBlobOutput: ... + + @overload + async def malformed_blob( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedBlobInputDict], + ) -> models.MalformedBlobOutput: + """ + Invokes the MalformedBlob operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_blob( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedBlobOutput: + return await self._invoke( + self._select_input(models.MALFORMED_BLOB, args, kwargs), + models.MALFORMED_BLOB, + [], + plugins, + ) + + @overload + async def malformed_boolean( + self, + request: models.MalformedBooleanInput | models.MalformedBooleanInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedBooleanOutput: ... + + @overload + async def malformed_boolean( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedBooleanInputDict], + ) -> models.MalformedBooleanOutput: + """ + Invokes the MalformedBoolean operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_boolean( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedBooleanOutput: + return await self._invoke( + self._select_input(models.MALFORMED_BOOLEAN, args, kwargs), + models.MALFORMED_BOOLEAN, + [], + plugins, + ) + + @overload + async def malformed_byte( + self, + request: models.MalformedByteInput | models.MalformedByteInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedByteOutput: ... + + @overload + async def malformed_byte( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedByteInputDict], + ) -> models.MalformedByteOutput: + """ + Invokes the MalformedByte operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_byte( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedByteOutput: + return await self._invoke( + self._select_input(models.MALFORMED_BYTE, args, kwargs), + models.MALFORMED_BYTE, + [], + plugins, + ) + + @overload + async def malformed_content_type_with_body( + self, + request: models.MalformedContentTypeWithBodyInput + | models.MalformedContentTypeWithBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithBodyOutput: ... + + @overload + async def malformed_content_type_with_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithBodyInputDict], + ) -> models.MalformedContentTypeWithBodyOutput: + """ + Invokes the MalformedContentTypeWithBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_content_type_with_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithBodyOutput: + return await self._invoke( + self._select_input(models.MALFORMED_CONTENT_TYPE_WITH_BODY, args, kwargs), + models.MALFORMED_CONTENT_TYPE_WITH_BODY, + [], + plugins, + ) + + @overload + async def malformed_content_type_with_generic_string( + self, + request: models.MalformedContentTypeWithGenericStringInput + | models.MalformedContentTypeWithGenericStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithGenericStringOutput: ... + + @overload + async def malformed_content_type_with_generic_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithGenericStringInputDict], + ) -> models.MalformedContentTypeWithGenericStringOutput: + """ + Invokes the MalformedContentTypeWithGenericString operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_content_type_with_generic_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithGenericStringOutput: + return await self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING, + [], + plugins, + ) + + @overload + async def malformed_content_type_with_payload( + self, + request: models.MalformedContentTypeWithPayloadInput + | models.MalformedContentTypeWithPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithPayloadOutput: ... + + @overload + async def malformed_content_type_with_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithPayloadInputDict], + ) -> models.MalformedContentTypeWithPayloadOutput: + """ + Invokes the MalformedContentTypeWithPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_content_type_with_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithPayloadOutput: + return await self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITH_PAYLOAD, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITH_PAYLOAD, + [], + plugins, + ) + + @overload + async def malformed_content_type_without_body( + self, + request: models.MalformedContentTypeWithoutBodyInput + | models.MalformedContentTypeWithoutBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithoutBodyOutput: ... + + @overload + async def malformed_content_type_without_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithoutBodyInputDict], + ) -> models.MalformedContentTypeWithoutBodyOutput: + """ + Invokes the MalformedContentTypeWithoutBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_content_type_without_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithoutBodyOutput: + return await self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY, + [], + plugins, + ) + + @overload + async def malformed_content_type_without_body_empty_input( + self, + request: models.MalformedContentTypeWithoutBodyEmptyInputInput + | models.MalformedContentTypeWithoutBodyEmptyInputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithoutBodyEmptyInputOutput: ... + + @overload + async def malformed_content_type_without_body_empty_input( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithoutBodyEmptyInputInputDict], + ) -> models.MalformedContentTypeWithoutBodyEmptyInputOutput: + """ + Invokes the MalformedContentTypeWithoutBodyEmptyInput operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_content_type_without_body_empty_input( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithoutBodyEmptyInputOutput: + return await self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT, + [], + plugins, + ) + + @overload + async def malformed_double( + self, + request: models.MalformedDoubleInput | models.MalformedDoubleInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedDoubleOutput: ... + + @overload + async def malformed_double( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedDoubleInputDict], + ) -> models.MalformedDoubleOutput: + """ + Invokes the MalformedDouble operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_double( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedDoubleOutput: + return await self._invoke( + self._select_input(models.MALFORMED_DOUBLE, args, kwargs), + models.MALFORMED_DOUBLE, + [], + plugins, + ) + + @overload + async def malformed_float( + self, + request: models.MalformedFloatInput | models.MalformedFloatInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedFloatOutput: ... + + @overload + async def malformed_float( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedFloatInputDict], + ) -> models.MalformedFloatOutput: + """ + Invokes the MalformedFloat operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_float( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedFloatOutput: + return await self._invoke( + self._select_input(models.MALFORMED_FLOAT, args, kwargs), + models.MALFORMED_FLOAT, + [], + plugins, + ) + + @overload + async def malformed_integer( + self, + request: models.MalformedIntegerInput | models.MalformedIntegerInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedIntegerOutput: ... + + @overload + async def malformed_integer( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedIntegerInputDict], + ) -> models.MalformedIntegerOutput: + """ + Invokes the MalformedInteger operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_integer( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedIntegerOutput: + return await self._invoke( + self._select_input(models.MALFORMED_INTEGER, args, kwargs), + models.MALFORMED_INTEGER, + [], + plugins, + ) + + @overload + async def malformed_list( + self, + request: models.MalformedListInput | models.MalformedListInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedListOutput: ... + + @overload + async def malformed_list( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedListInputDict], + ) -> models.MalformedListOutput: + """ + Invokes the MalformedList operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_list( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedListOutput: + return await self._invoke( + self._select_input(models.MALFORMED_LIST, args, kwargs), + models.MALFORMED_LIST, + [], + plugins, + ) + + @overload + async def malformed_long( + self, + request: models.MalformedLongInput | models.MalformedLongInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedLongOutput: ... + + @overload + async def malformed_long( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedLongInputDict], + ) -> models.MalformedLongOutput: + """ + Invokes the MalformedLong operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_long( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedLongOutput: + return await self._invoke( + self._select_input(models.MALFORMED_LONG, args, kwargs), + models.MALFORMED_LONG, + [], + plugins, + ) + + @overload + async def malformed_map( + self, + request: models.MalformedMapInput | models.MalformedMapInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedMapOutput: ... + + @overload + async def malformed_map( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedMapInputDict], + ) -> models.MalformedMapOutput: + """ + Invokes the MalformedMap operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_map( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedMapOutput: + return await self._invoke( + self._select_input(models.MALFORMED_MAP, args, kwargs), + models.MALFORMED_MAP, + [], + plugins, + ) + + @overload + async def malformed_request_body( + self, + request: models.MalformedRequestBodyInput + | models.MalformedRequestBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedRequestBodyOutput: ... + + @overload + async def malformed_request_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedRequestBodyInputDict], + ) -> models.MalformedRequestBodyOutput: + """ + Invokes the MalformedRequestBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_request_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedRequestBodyOutput: + return await self._invoke( + self._select_input(models.MALFORMED_REQUEST_BODY, args, kwargs), + models.MALFORMED_REQUEST_BODY, + [], + plugins, + ) + + @overload + async def malformed_short( + self, + request: models.MalformedShortInput | models.MalformedShortInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedShortOutput: ... + + @overload + async def malformed_short( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedShortInputDict], + ) -> models.MalformedShortOutput: + """ + Invokes the MalformedShort operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_short( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedShortOutput: + return await self._invoke( + self._select_input(models.MALFORMED_SHORT, args, kwargs), + models.MALFORMED_SHORT, + [], + plugins, + ) + + @overload + async def malformed_string( + self, + request: models.MalformedStringInput | models.MalformedStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedStringOutput: ... + + @overload + async def malformed_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedStringInputDict], + ) -> models.MalformedStringOutput: + """ + Invokes the MalformedString operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedStringOutput: + return await self._invoke( + self._select_input(models.MALFORMED_STRING, args, kwargs), + models.MALFORMED_STRING, + [], + plugins, + ) + + @overload + async def malformed_timestamp_body_date_time( + self, + request: models.MalformedTimestampBodyDateTimeInput + | models.MalformedTimestampBodyDateTimeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampBodyDateTimeOutput: ... + + @overload + async def malformed_timestamp_body_date_time( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampBodyDateTimeInputDict], + ) -> models.MalformedTimestampBodyDateTimeOutput: + """ + Invokes the MalformedTimestampBodyDateTime operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_body_date_time( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampBodyDateTimeOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_BODY_DATE_TIME, args, kwargs), + models.MALFORMED_TIMESTAMP_BODY_DATE_TIME, + [], + plugins, + ) + + @overload + async def malformed_timestamp_body_default( + self, + request: models.MalformedTimestampBodyDefaultInput + | models.MalformedTimestampBodyDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampBodyDefaultOutput: ... + + @overload + async def malformed_timestamp_body_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampBodyDefaultInputDict], + ) -> models.MalformedTimestampBodyDefaultOutput: + """ + Invokes the MalformedTimestampBodyDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_body_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampBodyDefaultOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_BODY_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_BODY_DEFAULT, + [], + plugins, + ) + + @overload + async def malformed_timestamp_body_http_date( + self, + request: models.MalformedTimestampBodyHttpDateInput + | models.MalformedTimestampBodyHttpDateInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampBodyHttpDateOutput: ... + + @overload + async def malformed_timestamp_body_http_date( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampBodyHttpDateInputDict], + ) -> models.MalformedTimestampBodyHttpDateOutput: + """ + Invokes the MalformedTimestampBodyHttpDate operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_body_http_date( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampBodyHttpDateOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_BODY_HTTP_DATE, args, kwargs), + models.MALFORMED_TIMESTAMP_BODY_HTTP_DATE, + [], + plugins, + ) + + @overload + async def malformed_timestamp_header_date_time( + self, + request: models.MalformedTimestampHeaderDateTimeInput + | models.MalformedTimestampHeaderDateTimeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampHeaderDateTimeOutput: ... + + @overload + async def malformed_timestamp_header_date_time( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampHeaderDateTimeInputDict], + ) -> models.MalformedTimestampHeaderDateTimeOutput: + """ + Invokes the MalformedTimestampHeaderDateTime operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_header_date_time( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampHeaderDateTimeOutput: + return await self._invoke( + self._select_input( + models.MALFORMED_TIMESTAMP_HEADER_DATE_TIME, args, kwargs + ), + models.MALFORMED_TIMESTAMP_HEADER_DATE_TIME, + [], + plugins, + ) + + @overload + async def malformed_timestamp_header_default( + self, + request: models.MalformedTimestampHeaderDefaultInput + | models.MalformedTimestampHeaderDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampHeaderDefaultOutput: ... + + @overload + async def malformed_timestamp_header_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampHeaderDefaultInputDict], + ) -> models.MalformedTimestampHeaderDefaultOutput: + """ + Invokes the MalformedTimestampHeaderDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_header_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampHeaderDefaultOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_HEADER_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_HEADER_DEFAULT, + [], + plugins, + ) + + @overload + async def malformed_timestamp_header_epoch( + self, + request: models.MalformedTimestampHeaderEpochInput + | models.MalformedTimestampHeaderEpochInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampHeaderEpochOutput: ... + + @overload + async def malformed_timestamp_header_epoch( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampHeaderEpochInputDict], + ) -> models.MalformedTimestampHeaderEpochOutput: + """ + Invokes the MalformedTimestampHeaderEpoch operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_header_epoch( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampHeaderEpochOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_HEADER_EPOCH, args, kwargs), + models.MALFORMED_TIMESTAMP_HEADER_EPOCH, + [], + plugins, + ) + + @overload + async def malformed_timestamp_path_default( + self, + request: models.MalformedTimestampPathDefaultInput + | models.MalformedTimestampPathDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampPathDefaultOutput: ... + + @overload + async def malformed_timestamp_path_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampPathDefaultInputDict], + ) -> models.MalformedTimestampPathDefaultOutput: + """ + Invokes the MalformedTimestampPathDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_path_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampPathDefaultOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_PATH_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_PATH_DEFAULT, + [], + plugins, + ) + + @overload + async def malformed_timestamp_path_epoch( + self, + request: models.MalformedTimestampPathEpochInput + | models.MalformedTimestampPathEpochInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampPathEpochOutput: ... + + @overload + async def malformed_timestamp_path_epoch( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampPathEpochInputDict], + ) -> models.MalformedTimestampPathEpochOutput: + """ + Invokes the MalformedTimestampPathEpoch operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_path_epoch( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampPathEpochOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_PATH_EPOCH, args, kwargs), + models.MALFORMED_TIMESTAMP_PATH_EPOCH, + [], + plugins, + ) + + @overload + async def malformed_timestamp_path_http_date( + self, + request: models.MalformedTimestampPathHttpDateInput + | models.MalformedTimestampPathHttpDateInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampPathHttpDateOutput: ... + + @overload + async def malformed_timestamp_path_http_date( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampPathHttpDateInputDict], + ) -> models.MalformedTimestampPathHttpDateOutput: + """ + Invokes the MalformedTimestampPathHttpDate operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_path_http_date( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampPathHttpDateOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_PATH_HTTP_DATE, args, kwargs), + models.MALFORMED_TIMESTAMP_PATH_HTTP_DATE, + [], + plugins, + ) + + @overload + async def malformed_timestamp_query_default( + self, + request: models.MalformedTimestampQueryDefaultInput + | models.MalformedTimestampQueryDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampQueryDefaultOutput: ... + + @overload + async def malformed_timestamp_query_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampQueryDefaultInputDict], + ) -> models.MalformedTimestampQueryDefaultOutput: + """ + Invokes the MalformedTimestampQueryDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_query_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampQueryDefaultOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_QUERY_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_QUERY_DEFAULT, + [], + plugins, + ) + + @overload + async def malformed_timestamp_query_epoch( + self, + request: models.MalformedTimestampQueryEpochInput + | models.MalformedTimestampQueryEpochInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampQueryEpochOutput: ... + + @overload + async def malformed_timestamp_query_epoch( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampQueryEpochInputDict], + ) -> models.MalformedTimestampQueryEpochOutput: + """ + Invokes the MalformedTimestampQueryEpoch operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_query_epoch( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampQueryEpochOutput: + return await self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_QUERY_EPOCH, args, kwargs), + models.MALFORMED_TIMESTAMP_QUERY_EPOCH, + [], + plugins, + ) + + @overload + async def malformed_timestamp_query_http_date( + self, + request: models.MalformedTimestampQueryHttpDateInput + | models.MalformedTimestampQueryHttpDateInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampQueryHttpDateOutput: ... + + @overload + async def malformed_timestamp_query_http_date( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampQueryHttpDateInputDict], + ) -> models.MalformedTimestampQueryHttpDateOutput: + """ + Invokes the MalformedTimestampQueryHttpDate operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_timestamp_query_http_date( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampQueryHttpDateOutput: + return await self._invoke( + self._select_input( + models.MALFORMED_TIMESTAMP_QUERY_HTTP_DATE, args, kwargs + ), + models.MALFORMED_TIMESTAMP_QUERY_HTTP_DATE, + [], + plugins, + ) + + @overload + async def malformed_union( + self, + request: models.MalformedUnionInput | models.MalformedUnionInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedUnionOutput: ... + + @overload + async def malformed_union( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedUnionInputDict], + ) -> models.MalformedUnionOutput: + """ + Invokes the MalformedUnion operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def malformed_union( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedUnionOutput: + return await self._invoke( + self._select_input(models.MALFORMED_UNION, args, kwargs), + models.MALFORMED_UNION, + [], + plugins, + ) + + @overload + async def media_type_header( + self, + request: models.MediaTypeHeaderInput | models.MediaTypeHeaderInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MediaTypeHeaderOutput: ... + + @overload + async def media_type_header( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MediaTypeHeaderInputDict], + ) -> models.MediaTypeHeaderOutput: + """ + This example ensures that mediaType strings are base64 encoded in + headers. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def media_type_header( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MediaTypeHeaderOutput: + return await self._invoke( + self._select_input(models.MEDIA_TYPE_HEADER, args, kwargs), + models.MEDIA_TYPE_HEADER, + [], + plugins, + ) + + @overload + async def no_input_and_no_output( + self, + request: models.NoInputAndNoOutputInput | models.NoInputAndNoOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NoInputAndNoOutputOutput: ... + + @overload + async def no_input_and_no_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NoInputAndNoOutputInputDict], + ) -> models.NoInputAndNoOutputOutput: + """ + The example tests how requests and responses are serialized when there's + no request or response payload because the operation has no input or + output. + While this should be rare, code generators must support this. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def no_input_and_no_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NoInputAndNoOutputOutput: + return await self._invoke( + self._select_input(models.NO_INPUT_AND_NO_OUTPUT, args, kwargs), + models.NO_INPUT_AND_NO_OUTPUT, + [], + plugins, + ) + + @overload + async def no_input_and_output( + self, + request: models.NoInputAndOutputInput | models.NoInputAndOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NoInputAndOutputOutput: ... + + @overload + async def no_input_and_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NoInputAndOutputInputDict], + ) -> models.NoInputAndOutputOutput: + """ + The example tests how requests and responses are serialized when there's + no request or response payload because the operation has no input and + the + output is empty. While this should be rare, code generators must support + this. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def no_input_and_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NoInputAndOutputOutput: + return await self._invoke( + self._select_input(models.NO_INPUT_AND_OUTPUT, args, kwargs), + models.NO_INPUT_AND_OUTPUT, + [], + plugins, + ) + + @overload + async def null_and_empty_headers_client( + self, + request: models.NullAndEmptyHeadersClientInput + | models.NullAndEmptyHeadersClientInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NullAndEmptyHeadersClientOutput: ... + + @overload + async def null_and_empty_headers_client( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NullAndEmptyHeadersClientInputDict], + ) -> models.NullAndEmptyHeadersClientOutput: + """ + Null headers are not sent over the wire, empty headers are serialized to + "" + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def null_and_empty_headers_client( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NullAndEmptyHeadersClientOutput: + return await self._invoke( + self._select_input(models.NULL_AND_EMPTY_HEADERS_CLIENT, args, kwargs), + models.NULL_AND_EMPTY_HEADERS_CLIENT, + [], + plugins, + ) + + @overload + async def null_and_empty_headers_server( + self, + request: models.NullAndEmptyHeadersServerInput + | models.NullAndEmptyHeadersServerInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NullAndEmptyHeadersServerOutput: ... + + @overload + async def null_and_empty_headers_server( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NullAndEmptyHeadersServerInputDict], + ) -> models.NullAndEmptyHeadersServerOutput: + """ + Null headers are not sent over the wire, empty headers are serialized to + "" + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def null_and_empty_headers_server( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NullAndEmptyHeadersServerOutput: + return await self._invoke( + self._select_input(models.NULL_AND_EMPTY_HEADERS_SERVER, args, kwargs), + models.NULL_AND_EMPTY_HEADERS_SERVER, + [], + plugins, + ) + + @overload + async def omits_null_serializes_empty_string( + self, + request: models.OmitsNullSerializesEmptyStringInput + | models.OmitsNullSerializesEmptyStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OmitsNullSerializesEmptyStringOutput: ... + + @overload + async def omits_null_serializes_empty_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OmitsNullSerializesEmptyStringInputDict], + ) -> models.OmitsNullSerializesEmptyStringOutput: + """ + Omits null, but serializes empty string value. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def omits_null_serializes_empty_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OmitsNullSerializesEmptyStringOutput: + return await self._invoke( + self._select_input(models.OMITS_NULL_SERIALIZES_EMPTY_STRING, args, kwargs), + models.OMITS_NULL_SERIALIZES_EMPTY_STRING, + [], + plugins, + ) + + @overload + async def omits_serializing_empty_lists( + self, + request: models.OmitsSerializingEmptyListsInput + | models.OmitsSerializingEmptyListsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OmitsSerializingEmptyListsOutput: ... + + @overload + async def omits_serializing_empty_lists( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OmitsSerializingEmptyListsInputDict], + ) -> models.OmitsSerializingEmptyListsOutput: + """ + Omits serializing empty lists. Because empty strings are serilized as + `Foo=`, empty lists cannot also be serialized as `Foo=` and instead + must be omitted. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def omits_serializing_empty_lists( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OmitsSerializingEmptyListsOutput: + return await self._invoke( + self._select_input(models.OMITS_SERIALIZING_EMPTY_LISTS, args, kwargs), + models.OMITS_SERIALIZING_EMPTY_LISTS, + [], + plugins, + ) + + @overload + async def operation_with_defaults( + self, + request: models.OperationWithDefaultsInput + | models.OperationWithDefaultsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OperationWithDefaultsOutput: ... + + @overload + async def operation_with_defaults( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OperationWithDefaultsInputDict], + ) -> models.OperationWithDefaultsOutput: + """ + Invokes the OperationWithDefaults operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def operation_with_defaults( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OperationWithDefaultsOutput: + return await self._invoke( + self._select_input(models.OPERATION_WITH_DEFAULTS, args, kwargs), + models.OPERATION_WITH_DEFAULTS, + [], + plugins, + ) + + @overload + async def operation_with_nested_structure( + self, + request: models.OperationWithNestedStructureInput + | models.OperationWithNestedStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OperationWithNestedStructureOutput: ... + + @overload + async def operation_with_nested_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OperationWithNestedStructureInputDict], + ) -> models.OperationWithNestedStructureOutput: + """ + Invokes the OperationWithNestedStructure operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def operation_with_nested_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OperationWithNestedStructureOutput: + return await self._invoke( + self._select_input(models.OPERATION_WITH_NESTED_STRUCTURE, args, kwargs), + models.OPERATION_WITH_NESTED_STRUCTURE, + [], + plugins, + ) + + @overload + async def post_player_action( + self, + request: models.PostPlayerActionInput | models.PostPlayerActionInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.PostPlayerActionOutput: ... + + @overload + async def post_player_action( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.PostPlayerActionInputDict], + ) -> models.PostPlayerActionOutput: + """ + This operation defines a union with a Unit member. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def post_player_action( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.PostPlayerActionOutput: + return await self._invoke( + self._select_input(models.POST_PLAYER_ACTION, args, kwargs), + models.POST_PLAYER_ACTION, + [], + plugins, + ) + + @overload + async def post_union_with_json_name( + self, + request: models.PostUnionWithJsonNameInput + | models.PostUnionWithJsonNameInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.PostUnionWithJsonNameOutput: ... + + @overload + async def post_union_with_json_name( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.PostUnionWithJsonNameInputDict], + ) -> models.PostUnionWithJsonNameOutput: + """ + This operation defines a union that uses jsonName on some members. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def post_union_with_json_name( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.PostUnionWithJsonNameOutput: + return await self._invoke( + self._select_input(models.POST_UNION_WITH_JSON_NAME, args, kwargs), + models.POST_UNION_WITH_JSON_NAME, + [], + plugins, + ) + + @overload + async def put_with_content_encoding( + self, + request: models.PutWithContentEncodingInput + | models.PutWithContentEncodingInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.PutWithContentEncodingOutput: ... + + @overload + async def put_with_content_encoding( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.PutWithContentEncodingInputDict], + ) -> models.PutWithContentEncodingOutput: + """ + Invokes the PutWithContentEncoding operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def put_with_content_encoding( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.PutWithContentEncodingOutput: + return await self._invoke( + self._select_input(models.PUT_WITH_CONTENT_ENCODING, args, kwargs), + models.PUT_WITH_CONTENT_ENCODING, + [], + plugins, + ) + + @overload + async def query_idempotency_token_auto_fill( + self, + request: models.QueryIdempotencyTokenAutoFillInput + | models.QueryIdempotencyTokenAutoFillInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.QueryIdempotencyTokenAutoFillOutput: ... + + @overload + async def query_idempotency_token_auto_fill( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.QueryIdempotencyTokenAutoFillInputDict], + ) -> models.QueryIdempotencyTokenAutoFillOutput: + """ + Automatically adds idempotency tokens. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def query_idempotency_token_auto_fill( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.QueryIdempotencyTokenAutoFillOutput: + return await self._invoke( + self._select_input(models.QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, args, kwargs), + models.QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, + [], + plugins, + ) + + @overload + async def query_params_as_string_list_map( + self, + request: models.QueryParamsAsStringListMapInput + | models.QueryParamsAsStringListMapInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.QueryParamsAsStringListMapOutput: ... + + @overload + async def query_params_as_string_list_map( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.QueryParamsAsStringListMapInputDict], + ) -> models.QueryParamsAsStringListMapOutput: + """ + Invokes the QueryParamsAsStringListMap operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def query_params_as_string_list_map( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.QueryParamsAsStringListMapOutput: + return await self._invoke( + self._select_input(models.QUERY_PARAMS_AS_STRING_LIST_MAP, args, kwargs), + models.QUERY_PARAMS_AS_STRING_LIST_MAP, + [], + plugins, + ) + + @overload + async def query_precedence( + self, + request: models.QueryPrecedenceInput | models.QueryPrecedenceInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.QueryPrecedenceOutput: ... + + @overload + async def query_precedence( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.QueryPrecedenceInputDict], + ) -> models.QueryPrecedenceOutput: + """ + Invokes the QueryPrecedence operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def query_precedence( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.QueryPrecedenceOutput: + return await self._invoke( + self._select_input(models.QUERY_PRECEDENCE, args, kwargs), + models.QUERY_PRECEDENCE, + [], + plugins, + ) + + @overload + async def recursive_shapes( + self, + request: models.RecursiveShapesInput | models.RecursiveShapesInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.RecursiveShapesOutput: ... + + @overload + async def recursive_shapes( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.RecursiveShapesInputDict], + ) -> models.RecursiveShapesOutput: + """ + Recursive shapes + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def recursive_shapes( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.RecursiveShapesOutput: + return await self._invoke( + self._select_input(models.RECURSIVE_SHAPES, args, kwargs), + models.RECURSIVE_SHAPES, + [], + plugins, + ) + + @overload + async def response_code_http_fallback( + self, + request: models.ResponseCodeHttpFallbackInput + | models.ResponseCodeHttpFallbackInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ResponseCodeHttpFallbackOutput: ... + + @overload + async def response_code_http_fallback( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ResponseCodeHttpFallbackInputDict], + ) -> models.ResponseCodeHttpFallbackOutput: + """ + Invokes the ResponseCodeHttpFallback operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def response_code_http_fallback( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ResponseCodeHttpFallbackOutput: + return await self._invoke( + self._select_input(models.RESPONSE_CODE_HTTP_FALLBACK, args, kwargs), + models.RESPONSE_CODE_HTTP_FALLBACK, + [], + plugins, + ) + + @overload + async def response_code_required( + self, + request: models.ResponseCodeRequiredInput + | models.ResponseCodeRequiredInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ResponseCodeRequiredOutput: ... + + @overload + async def response_code_required( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ResponseCodeRequiredInputDict], + ) -> models.ResponseCodeRequiredOutput: + """ + Invokes the ResponseCodeRequired operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def response_code_required( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ResponseCodeRequiredOutput: + return await self._invoke( + self._select_input(models.RESPONSE_CODE_REQUIRED, args, kwargs), + models.RESPONSE_CODE_REQUIRED, + [], + plugins, + ) + + @overload + async def simple_scalar_properties( + self, + request: models.SimpleScalarPropertiesInput + | models.SimpleScalarPropertiesInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.SimpleScalarPropertiesOutput: ... + + @overload + async def simple_scalar_properties( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.SimpleScalarPropertiesInputDict], + ) -> models.SimpleScalarPropertiesOutput: + """ + Invokes the SimpleScalarProperties operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def simple_scalar_properties( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.SimpleScalarPropertiesOutput: + return await self._invoke( + self._select_input(models.SIMPLE_SCALAR_PROPERTIES, args, kwargs), + models.SIMPLE_SCALAR_PROPERTIES, + [], + plugins, + ) + + @overload + async def sparse_json_lists( + self, + request: models.SparseJsonListsInput | models.SparseJsonListsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.SparseJsonListsOutput: ... + + @overload + async def sparse_json_lists( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.SparseJsonListsInputDict], + ) -> models.SparseJsonListsOutput: + """ + Invokes the SparseJsonLists operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def sparse_json_lists( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.SparseJsonListsOutput: + return await self._invoke( + self._select_input(models.SPARSE_JSON_LISTS, args, kwargs), + models.SPARSE_JSON_LISTS, + [], + plugins, + ) + + @overload + async def sparse_json_maps( + self, + request: models.SparseJsonMapsInput | models.SparseJsonMapsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.SparseJsonMapsOutput: ... + + @overload + async def sparse_json_maps( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.SparseJsonMapsInputDict], + ) -> models.SparseJsonMapsOutput: + """ + This example tests sparse map serialization. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def sparse_json_maps( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.SparseJsonMapsOutput: + return await self._invoke( + self._select_input(models.SPARSE_JSON_MAPS, args, kwargs), + models.SPARSE_JSON_MAPS, + [], + plugins, + ) + + @overload + async def test_body_structure( + self, + request: models.TestBodyStructureInput | models.TestBodyStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestBodyStructureOutput: ... + + @overload + async def test_body_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestBodyStructureInputDict], + ) -> models.TestBodyStructureOutput: + """ + This example operation serializes a structure in the HTTP body. + + It should ensure Content-Type: application/json is + used in all requests and that an "empty" body is + an empty JSON document ({}). + + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def test_body_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestBodyStructureOutput: + return await self._invoke( + self._select_input(models.TEST_BODY_STRUCTURE, args, kwargs), + models.TEST_BODY_STRUCTURE, + [], + plugins, + ) + + @overload + async def test_get_no_input_no_payload( + self, + request: models.TestGetNoInputNoPayloadInput + | models.TestGetNoInputNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestGetNoInputNoPayloadOutput: ... + + @overload + async def test_get_no_input_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestGetNoInputNoPayloadInputDict], + ) -> models.TestGetNoInputNoPayloadOutput: + """ + This example GET operation has no input and serializes a request without + a HTTP body. + + These tests are to ensure we do not attach a body or related headers + (Content-Length, Content-Type) to operations that semantically + cannot produce an HTTP body. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def test_get_no_input_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestGetNoInputNoPayloadOutput: + return await self._invoke( + self._select_input(models.TEST_GET_NO_INPUT_NO_PAYLOAD, args, kwargs), + models.TEST_GET_NO_INPUT_NO_PAYLOAD, + [], + plugins, + ) + + @overload + async def test_get_no_payload( + self, + request: models.TestGetNoPayloadInput | models.TestGetNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestGetNoPayloadOutput: ... + + @overload + async def test_get_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestGetNoPayloadInputDict], + ) -> models.TestGetNoPayloadOutput: + """ + This example GET operation serializes a request without a modeled HTTP + body. + + These tests are to ensure we do not attach a body or related headers + (Content-Length, Content-Type) to operations that semantically + cannot produce an HTTP body. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def test_get_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestGetNoPayloadOutput: + return await self._invoke( + self._select_input(models.TEST_GET_NO_PAYLOAD, args, kwargs), + models.TEST_GET_NO_PAYLOAD, + [], + plugins, + ) + + @overload + async def test_payload_blob( + self, + request: models.TestPayloadBlobInput | models.TestPayloadBlobInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPayloadBlobOutput: ... + + @overload + async def test_payload_blob( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPayloadBlobInputDict], + ) -> models.TestPayloadBlobOutput: + """ + This example operation serializes a payload targeting a blob. + + The Blob shape is not structured content and we cannot + make assumptions about what data will be sent. This test ensures + only a generic "Content-Type: application/octet-stream" header + is used, and that we are not treating an empty body as an + empty JSON document. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def test_payload_blob( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPayloadBlobOutput: + return await self._invoke( + self._select_input(models.TEST_PAYLOAD_BLOB, args, kwargs), + models.TEST_PAYLOAD_BLOB, + [], + plugins, + ) + + @overload + async def test_payload_structure( + self, + request: models.TestPayloadStructureInput + | models.TestPayloadStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPayloadStructureOutput: ... + + @overload + async def test_payload_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPayloadStructureInputDict], + ) -> models.TestPayloadStructureOutput: + """ + This example operation serializes a payload targeting a structure. + + This enforces the same requirements as TestBodyStructure + but with the body specified by the @httpPayload trait. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def test_payload_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPayloadStructureOutput: + return await self._invoke( + self._select_input(models.TEST_PAYLOAD_STRUCTURE, args, kwargs), + models.TEST_PAYLOAD_STRUCTURE, + [], + plugins, + ) + + @overload + async def test_post_no_input_no_payload( + self, + request: models.TestPostNoInputNoPayloadInput + | models.TestPostNoInputNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPostNoInputNoPayloadOutput: ... + + @overload + async def test_post_no_input_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPostNoInputNoPayloadInputDict], + ) -> models.TestPostNoInputNoPayloadOutput: + """ + This example POST operation has no input and serializes a request + without a HTTP body. + + These tests are to ensure we do not attach a body or related headers + (Content-Type) to a POST operation with no modeled input. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def test_post_no_input_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPostNoInputNoPayloadOutput: + return await self._invoke( + self._select_input(models.TEST_POST_NO_INPUT_NO_PAYLOAD, args, kwargs), + models.TEST_POST_NO_INPUT_NO_PAYLOAD, + [], + plugins, + ) + + @overload + async def test_post_no_payload( + self, + request: models.TestPostNoPayloadInput | models.TestPostNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPostNoPayloadOutput: ... + + @overload + async def test_post_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPostNoPayloadInputDict], + ) -> models.TestPostNoPayloadOutput: + """ + This example POST operation serializes a request without a modeled HTTP + body. + + These tests are to ensure we do not attach a body or related headers + (Content-Type) to a POST operation with no modeled payload. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def test_post_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPostNoPayloadOutput: + return await self._invoke( + self._select_input(models.TEST_POST_NO_PAYLOAD, args, kwargs), + models.TEST_POST_NO_PAYLOAD, + [], + plugins, + ) + + @overload + async def timestamp_format_headers( + self, + request: models.TimestampFormatHeadersInput + | models.TimestampFormatHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TimestampFormatHeadersOutput: ... + + @overload + async def timestamp_format_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TimestampFormatHeadersInputDict], + ) -> models.TimestampFormatHeadersOutput: + """ + This example tests how timestamp request and response headers are + serialized. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def timestamp_format_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TimestampFormatHeadersOutput: + return await self._invoke( + self._select_input(models.TIMESTAMP_FORMAT_HEADERS, args, kwargs), + models.TIMESTAMP_FORMAT_HEADERS, + [], + plugins, + ) + + @overload + async def unit_input_and_output( + self, + request: models.UnitInputAndOutputInput | models.UnitInputAndOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.UnitInputAndOutputOutput: ... + + @overload + async def unit_input_and_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.UnitInputAndOutputInputDict], + ) -> models.UnitInputAndOutputOutput: + """ + This test is similar to NoInputAndNoOutput, but uses explicit Unit + types. + + :param plugins: Callables that change the configuration for this call + only. + """ + + async def unit_input_and_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.UnitInputAndOutputOutput: + return await self._invoke( + self._select_input(models.UNIT_INPUT_AND_OUTPUT, args, kwargs), + models.UNIT_INPUT_AND_OUTPUT, + [], + plugins, + ) + + async def _new_config(self) -> AsyncRestJsonProtocolConfig: + return await AsyncRestJsonProtocolConfig.resolve() + + async def _post_setup(self, config: AsyncRestJsonProtocolConfig) -> None: + if config.aws_credentials_identity_resolver is None: + config_context = config.resolution_context() + config_file = None + profile_name = None + if config_context is not None: + config_file = await config_context.parsed_profiles() + if config_context.profile_source is ConfigSource.OVERRIDE: + profile_name = config_context.profile_name + config.aws_credentials_identity_resolver = await AsyncIdentityChain.create( + AWSCredentialsIdentity, + config_file=config_file, + profile_name=profile_name, + region_override=config.region, + http_client=cast(AsyncHTTPClient | None, config.transport), + ) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/aio/config.py b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/config.py new file mode 100644 index 000000000..ec1735777 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/config.py @@ -0,0 +1,123 @@ +from collections.abc import Callable +from dataclasses import dataclass, field +from typing import Any, ClassVar, Self, Unpack + +from smithy_aws_core.aio.auth.sigv4 import AsyncSigV4AuthScheme +from smithy_aws_core.aio.config.aws_config import ( + AsyncAwsConfig, + AsyncAwsConfigOverrides, +) +from smithy_aws_core.aio.config.filesystem import AsyncFileSystem +from smithy_aws_core.aio.protocols import AsyncRestJsonClientProtocol +from smithy_aws_core.config.resolvers import EndpointUriResolver +from smithy_aws_core.config.types import FieldSpec +from smithy_aws_core.endpoints import AWS_RULES_EXTENSION +from smithy_core.aio.interfaces import AsyncEndpointResolver +from smithy_core.aio.interfaces.auth import AsyncAuthScheme +from smithy_core.auth import DefaultAuthResolver +from smithy_core.endpoints import BddEndpointResolver +from smithy_core.interceptors import Interceptor +from smithy_core.interfaces import ( + ClientProtocol, + EndpointResolver, + ProtocolConstructor, + ProtocolSettings, +) +from smithy_core.interfaces.auth import AuthSchemeResolver +from smithy_core.shapes import ShapeID +from smithy_http.aio.aiohttp import AIOHTTPClient + +from restjson_client._private.endpoints import BDD +from restjson_client._private.schemas import REST_JSON + +_PROTOCOL_SETTINGS = ProtocolSettings( + namespace="aws.protocoltests.restjson", + service_target="RestJson", + version="2019-12-16", + service_schema=REST_JSON, +) + + +class _AsyncRestJsonProtocolConfigOverrides(AsyncAwsConfigOverrides, total=False): + "Explicit field values AsyncRestJsonProtocolConfig.resolve accepts." + + endpoint_resolver: EndpointResolver | AsyncEndpointResolver | None + protocol: ( + ClientProtocol[Any, Any] | ProtocolConstructor[ClientProtocol[Any, Any]] | None + ) + auth_schemes: dict[ShapeID, AsyncAuthScheme[Any, Any, Any, Any]] | None + auth_scheme_resolver: AuthSchemeResolver | None + + +@dataclass(kw_only=True, repr=False, init=False) +class AsyncRestJsonProtocolConfig(AsyncAwsConfig): + "Configuration for AsyncRestJsonProtocolClient." + + interceptors: list[Interceptor[Any, Any, Any, Any]] = field( + default_factory=list[Interceptor[Any, Any, Any, Any]] + ) + "Hooks called during the execution of a request." + + endpoint_resolver: EndpointResolver | AsyncEndpointResolver | None = None + "Resolves the endpoint of each operation." + + protocol: ClientProtocol[Any, Any] | None = None + "Serializes requests and deserializes responses." + + auth_schemes: dict[ShapeID, AsyncAuthScheme[Any, Any, Any, Any]] | None = None + "Auth schemes by auth scheme ID." + + auth_scheme_resolver: AuthSchemeResolver | None = None + "Determines the auth scheme for each operation." + + _FIELDS: ClassVar[dict[str, FieldSpec]] = { + **AsyncAwsConfig._FIELDS, + "endpoint_uri": FieldSpec( + default=None, resolver=EndpointUriResolver("rest_json_protocol").program + ), + "endpoint_resolver": FieldSpec( + default_factory=lambda: BddEndpointResolver( + BDD, extensions=[AWS_RULES_EXTENSION] + ) + ), + "protocol": FieldSpec( + default_factory=lambda: AsyncRestJsonClientProtocol(_PROTOCOL_SETTINGS), + converter=lambda p: p(_PROTOCOL_SETTINGS) if isinstance(p, type) else p, + ), + "auth_schemes": FieldSpec( + default_factory=lambda: { + ShapeID("aws.auth#sigv4"): AsyncSigV4AuthScheme(service="restjson") + } + ), + "auth_scheme_resolver": FieldSpec(default_factory=DefaultAuthResolver), + "transport": FieldSpec(default_factory=lambda: AIOHTTPClient()), + } + + def set_auth_scheme(self, scheme: AsyncAuthScheme[Any, Any, Any, Any]) -> None: + "Set an auth scheme under its scheme ID." + auth_schemes = dict(self.auth_schemes or {}) + auth_schemes[scheme.scheme_id] = scheme + self.auth_schemes = auth_schemes + + @classmethod + async def resolve( # pyright: ignore[reportIncompatibleMethodOverride] + cls, + *, + profile: str | None = None, + fs: AsyncFileSystem | None = None, + config_file_path: str | None = None, + credentials_file_path: str | None = None, + **overrides: Unpack[_AsyncRestJsonProtocolConfigOverrides], + ) -> Self: + "Resolve the config from overrides, the environment, and config files." + return await cls._resolve( + profile=profile, + fs=fs, + config_file_path=config_file_path, + credentials_file_path=credentials_file_path, + overrides=overrides, + ) + + +type Plugin = Callable[[AsyncRestJsonProtocolConfig], None] +"A callable that customizes the client configuration." diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/aio/user_agent.py b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/user_agent.py new file mode 100644 index 000000000..51c0650ca --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/aio/user_agent.py @@ -0,0 +1,16 @@ +from smithy_aws_core.interceptors.user_agent import UserAgentInterceptor + +from restjson_client import __version__ +from restjson_client.aio.config import AsyncRestJsonProtocolConfig + + +def aws_user_agent_plugin(config: AsyncRestJsonProtocolConfig) -> None: + "Send the AWS user agent with every request." + config.interceptors.append( + UserAgentInterceptor( + ua_suffix=config.user_agent_extra, + ua_app_id=config.sdk_ua_app_id, + sdk_version=__version__, + service_id="Rest_Json_Protocol", + ) + ) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/client.py b/codegen-output-py/rest-json-1-client/src/restjson_client/client.py new file mode 100644 index 000000000..bac042e3a --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/client.py @@ -0,0 +1,3717 @@ +from __future__ import annotations + +from typing import Unpack, cast, overload + +from smithy_aws_core.config.types import ConfigSource +from smithy_aws_core.identity.chain.resolver import IdentityChain +from smithy_aws_core.identity.components import AWSCredentialsIdentity +from smithy_core.client import Client +from smithy_http.interfaces import HTTPClient +from smithy_http.plugins import user_agent_plugin + +from restjson_client import models +from restjson_client.config import Plugin, RestJsonProtocolConfig +from restjson_client.user_agent import aws_user_agent_plugin + + +class RestJsonProtocolClient(Client[RestJsonProtocolConfig]): + "Client for RestJson." + + _client_plugins = (aws_user_agent_plugin, user_agent_plugin) + + @overload + def all_query_string_types( + self, + request: models.AllQueryStringTypesInput | models.AllQueryStringTypesInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.AllQueryStringTypesOutput: ... + + @overload + def all_query_string_types( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.AllQueryStringTypesInputDict], + ) -> models.AllQueryStringTypesOutput: + """ + This example uses all query string types. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def all_query_string_types( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.AllQueryStringTypesOutput: + return self._invoke( + self._select_input(models.ALL_QUERY_STRING_TYPES, args, kwargs), + models.ALL_QUERY_STRING_TYPES, + [], + plugins, + ) + + @overload + def constant_and_variable_query_string( + self, + request: models.ConstantAndVariableQueryStringInput + | models.ConstantAndVariableQueryStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ConstantAndVariableQueryStringOutput: ... + + @overload + def constant_and_variable_query_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ConstantAndVariableQueryStringInputDict], + ) -> models.ConstantAndVariableQueryStringOutput: + """ + This example uses fixed query string params and variable query string + params. + The fixed query string parameters and variable parameters must both be + serialized (implementations may need to merge them together). + + :param plugins: Callables that change the configuration for this call + only. + """ + + def constant_and_variable_query_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ConstantAndVariableQueryStringOutput: + return self._invoke( + self._select_input(models.CONSTANT_AND_VARIABLE_QUERY_STRING, args, kwargs), + models.CONSTANT_AND_VARIABLE_QUERY_STRING, + [], + plugins, + ) + + @overload + def constant_query_string( + self, + request: models.ConstantQueryStringInput | models.ConstantQueryStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ConstantQueryStringOutput: ... + + @overload + def constant_query_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ConstantQueryStringInputDict], + ) -> models.ConstantQueryStringOutput: + """ + This example uses a constant query string parameters and a label. + This simply tests that labels and query string parameters are + compatible. The fixed query string parameter named "hello" should + in no way conflict with the label, `{hello}`. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def constant_query_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ConstantQueryStringOutput: + return self._invoke( + self._select_input(models.CONSTANT_QUERY_STRING, args, kwargs), + models.CONSTANT_QUERY_STRING, + [], + plugins, + ) + + @overload + def content_type_parameters( + self, + request: models.ContentTypeParametersInput + | models.ContentTypeParametersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ContentTypeParametersOutput: ... + + @overload + def content_type_parameters( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ContentTypeParametersInputDict], + ) -> models.ContentTypeParametersOutput: + """ + The example tests how servers must support requests + containing a `Content-Type` header with parameters. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def content_type_parameters( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ContentTypeParametersOutput: + return self._invoke( + self._select_input(models.CONTENT_TYPE_PARAMETERS, args, kwargs), + models.CONTENT_TYPE_PARAMETERS, + [], + plugins, + ) + + @overload + def datetime_offsets( + self, + request: models.DatetimeOffsetsInput | models.DatetimeOffsetsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DatetimeOffsetsOutput: ... + + @overload + def datetime_offsets( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DatetimeOffsetsInputDict], + ) -> models.DatetimeOffsetsOutput: + """ + Invokes the DatetimeOffsets operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def datetime_offsets( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DatetimeOffsetsOutput: + return self._invoke( + self._select_input(models.DATETIME_OFFSETS, args, kwargs), + models.DATETIME_OFFSETS, + [], + plugins, + ) + + @overload + def document_type( + self, + request: models.DocumentTypeInput | models.DocumentTypeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DocumentTypeOutput: ... + + @overload + def document_type( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DocumentTypeInputDict], + ) -> models.DocumentTypeOutput: + """ + This example serializes a document as part of the payload. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def document_type( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DocumentTypeOutput: + return self._invoke( + self._select_input(models.DOCUMENT_TYPE, args, kwargs), + models.DOCUMENT_TYPE, + [], + plugins, + ) + + @overload + def document_type_as_map_value( + self, + request: models.DocumentTypeAsMapValueInput + | models.DocumentTypeAsMapValueInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DocumentTypeAsMapValueOutput: ... + + @overload + def document_type_as_map_value( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DocumentTypeAsMapValueInputDict], + ) -> models.DocumentTypeAsMapValueOutput: + """ + This example serializes documents as the value of maps. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def document_type_as_map_value( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DocumentTypeAsMapValueOutput: + return self._invoke( + self._select_input(models.DOCUMENT_TYPE_AS_MAP_VALUE, args, kwargs), + models.DOCUMENT_TYPE_AS_MAP_VALUE, + [], + plugins, + ) + + @overload + def document_type_as_payload( + self, + request: models.DocumentTypeAsPayloadInput + | models.DocumentTypeAsPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.DocumentTypeAsPayloadOutput: ... + + @overload + def document_type_as_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.DocumentTypeAsPayloadInputDict], + ) -> models.DocumentTypeAsPayloadOutput: + """ + This example serializes a document as the entire HTTP payload. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def document_type_as_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.DocumentTypeAsPayloadOutput: + return self._invoke( + self._select_input(models.DOCUMENT_TYPE_AS_PAYLOAD, args, kwargs), + models.DOCUMENT_TYPE_AS_PAYLOAD, + [], + plugins, + ) + + @overload + def empty_input_and_empty_output( + self, + request: models.EmptyInputAndEmptyOutputInput + | models.EmptyInputAndEmptyOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.EmptyInputAndEmptyOutputOutput: ... + + @overload + def empty_input_and_empty_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.EmptyInputAndEmptyOutputInputDict], + ) -> models.EmptyInputAndEmptyOutputOutput: + """ + The example tests how requests and responses are serialized when there's + no request or response payload because the operation has an empty input + and empty output structure that reuses the same shape. While this should + be rare, code generators must support this. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def empty_input_and_empty_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.EmptyInputAndEmptyOutputOutput: + return self._invoke( + self._select_input(models.EMPTY_INPUT_AND_EMPTY_OUTPUT, args, kwargs), + models.EMPTY_INPUT_AND_EMPTY_OUTPUT, + [], + plugins, + ) + + @overload + def endpoint_operation( + self, + request: models.EndpointOperationInput | models.EndpointOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.EndpointOperationOutput: ... + + @overload + def endpoint_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.EndpointOperationInputDict], + ) -> models.EndpointOperationOutput: + """ + Invokes the EndpointOperation operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def endpoint_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.EndpointOperationOutput: + return self._invoke( + self._select_input(models.ENDPOINT_OPERATION, args, kwargs), + models.ENDPOINT_OPERATION, + [], + plugins, + ) + + @overload + def endpoint_with_host_label_operation( + self, + request: models.EndpointWithHostLabelOperationInput + | models.EndpointWithHostLabelOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.EndpointWithHostLabelOperationOutput: ... + + @overload + def endpoint_with_host_label_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.EndpointWithHostLabelOperationInputDict], + ) -> models.EndpointWithHostLabelOperationOutput: + """ + Invokes the EndpointWithHostLabelOperation operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def endpoint_with_host_label_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.EndpointWithHostLabelOperationOutput: + return self._invoke( + self._select_input(models.ENDPOINT_WITH_HOST_LABEL_OPERATION, args, kwargs), + models.ENDPOINT_WITH_HOST_LABEL_OPERATION, + [], + plugins, + ) + + @overload + def fractional_seconds( + self, + request: models.FractionalSecondsInput | models.FractionalSecondsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.FractionalSecondsOutput: ... + + @overload + def fractional_seconds( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.FractionalSecondsInputDict], + ) -> models.FractionalSecondsOutput: + """ + Invokes the FractionalSeconds operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def fractional_seconds( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.FractionalSecondsOutput: + return self._invoke( + self._select_input(models.FRACTIONAL_SECONDS, args, kwargs), + models.FRACTIONAL_SECONDS, + [], + plugins, + ) + + @overload + def greeting_with_errors( + self, + request: models.GreetingWithErrorsInput | models.GreetingWithErrorsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.GreetingWithErrorsOutput: ... + + @overload + def greeting_with_errors( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.GreetingWithErrorsInputDict], + ) -> models.GreetingWithErrorsOutput: + """ + This operation has four possible return values: + + 1. A successful response in the form of GreetingWithErrorsOutput + 2. An InvalidGreeting error. + 3. A BadRequest error. + 4. A FooError. + + Implementations must be able to successfully take a response and + properly (de)serialize successful and error responses based on the + the presence of the + + :param plugins: Callables that change the configuration for this call + only. + """ + + def greeting_with_errors( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.GreetingWithErrorsOutput: + return self._invoke( + self._select_input(models.GREETING_WITH_ERRORS, args, kwargs), + models.GREETING_WITH_ERRORS, + [], + plugins, + ) + + @overload + def host_with_path_operation( + self, + request: models.HostWithPathOperationInput + | models.HostWithPathOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HostWithPathOperationOutput: ... + + @overload + def host_with_path_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HostWithPathOperationInputDict], + ) -> models.HostWithPathOperationOutput: + """ + Invokes the HostWithPathOperation operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def host_with_path_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HostWithPathOperationOutput: + return self._invoke( + self._select_input(models.HOST_WITH_PATH_OPERATION, args, kwargs), + models.HOST_WITH_PATH_OPERATION, + [], + plugins, + ) + + @overload + def http_checksum_required( + self, + request: models.HttpChecksumRequiredInput + | models.HttpChecksumRequiredInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpChecksumRequiredOutput: ... + + @overload + def http_checksum_required( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpChecksumRequiredInputDict], + ) -> models.HttpChecksumRequiredOutput: + """ + This example tests httpChecksumRequired trait + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_checksum_required( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpChecksumRequiredOutput: + return self._invoke( + self._select_input(models.HTTP_CHECKSUM_REQUIRED, args, kwargs), + models.HTTP_CHECKSUM_REQUIRED, + [], + plugins, + ) + + @overload + def http_empty_prefix_headers( + self, + request: models.HttpEmptyPrefixHeadersInput + | models.HttpEmptyPrefixHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpEmptyPrefixHeadersOutput: ... + + @overload + def http_empty_prefix_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpEmptyPrefixHeadersInputDict], + ) -> models.HttpEmptyPrefixHeadersOutput: + """ + Clients that perform this test extract all headers from the response. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_empty_prefix_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpEmptyPrefixHeadersOutput: + return self._invoke( + self._select_input(models.HTTP_EMPTY_PREFIX_HEADERS, args, kwargs), + models.HTTP_EMPTY_PREFIX_HEADERS, + [], + plugins, + ) + + @overload + def http_enum_payload( + self, + request: models.HttpEnumPayloadInput | models.HttpEnumPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpEnumPayloadOutput: ... + + @overload + def http_enum_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpEnumPayloadInputDict], + ) -> models.HttpEnumPayloadOutput: + """ + Invokes the HttpEnumPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_enum_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpEnumPayloadOutput: + return self._invoke( + self._select_input(models.HTTP_ENUM_PAYLOAD, args, kwargs), + models.HTTP_ENUM_PAYLOAD, + [], + plugins, + ) + + @overload + def http_payload_traits( + self, + request: models.HttpPayloadTraitsInput | models.HttpPayloadTraitsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadTraitsOutput: ... + + @overload + def http_payload_traits( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadTraitsInputDict], + ) -> models.HttpPayloadTraitsOutput: + """ + This example serializes a blob shape in the payload. + + In this example, no JSON document is synthesized because the payload is + not a structure or a union type. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_payload_traits( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadTraitsOutput: + return self._invoke( + self._select_input(models.HTTP_PAYLOAD_TRAITS, args, kwargs), + models.HTTP_PAYLOAD_TRAITS, + [], + plugins, + ) + + @overload + def http_payload_traits_with_media_type( + self, + request: models.HttpPayloadTraitsWithMediaTypeInput + | models.HttpPayloadTraitsWithMediaTypeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadTraitsWithMediaTypeOutput: ... + + @overload + def http_payload_traits_with_media_type( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadTraitsWithMediaTypeInputDict], + ) -> models.HttpPayloadTraitsWithMediaTypeOutput: + """ + This example uses a `@mediaType` trait on the payload to force a custom + content-type to be serialized. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_payload_traits_with_media_type( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadTraitsWithMediaTypeOutput: + return self._invoke( + self._select_input( + models.HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, args, kwargs + ), + models.HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE, + [], + plugins, + ) + + @overload + def http_payload_with_structure( + self, + request: models.HttpPayloadWithStructureInput + | models.HttpPayloadWithStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadWithStructureOutput: ... + + @overload + def http_payload_with_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadWithStructureInputDict], + ) -> models.HttpPayloadWithStructureOutput: + """ + This example serializes a structure in the payload. + + Note that serializing a structure changes the wrapper element name + to match the targeted structure. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_payload_with_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadWithStructureOutput: + return self._invoke( + self._select_input(models.HTTP_PAYLOAD_WITH_STRUCTURE, args, kwargs), + models.HTTP_PAYLOAD_WITH_STRUCTURE, + [], + plugins, + ) + + @overload + def http_payload_with_union( + self, + request: models.HttpPayloadWithUnionInput + | models.HttpPayloadWithUnionInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPayloadWithUnionOutput: ... + + @overload + def http_payload_with_union( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPayloadWithUnionInputDict], + ) -> models.HttpPayloadWithUnionOutput: + """ + This example serializes a union in the payload. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_payload_with_union( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPayloadWithUnionOutput: + return self._invoke( + self._select_input(models.HTTP_PAYLOAD_WITH_UNION, args, kwargs), + models.HTTP_PAYLOAD_WITH_UNION, + [], + plugins, + ) + + @overload + def http_prefix_headers( + self, + request: models.HttpPrefixHeadersInput | models.HttpPrefixHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPrefixHeadersOutput: ... + + @overload + def http_prefix_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPrefixHeadersInputDict], + ) -> models.HttpPrefixHeadersOutput: + """ + This examples adds headers to the input of a request and response by + prefix. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_prefix_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPrefixHeadersOutput: + return self._invoke( + self._select_input(models.HTTP_PREFIX_HEADERS, args, kwargs), + models.HTTP_PREFIX_HEADERS, + [], + plugins, + ) + + @overload + def http_prefix_headers_in_response( + self, + request: models.HttpPrefixHeadersInResponseInput + | models.HttpPrefixHeadersInResponseInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpPrefixHeadersInResponseOutput: ... + + @overload + def http_prefix_headers_in_response( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpPrefixHeadersInResponseInputDict], + ) -> models.HttpPrefixHeadersInResponseOutput: + """ + Clients that perform this test extract all headers from the response. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_prefix_headers_in_response( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpPrefixHeadersInResponseOutput: + return self._invoke( + self._select_input(models.HTTP_PREFIX_HEADERS_IN_RESPONSE, args, kwargs), + models.HTTP_PREFIX_HEADERS_IN_RESPONSE, + [], + plugins, + ) + + @overload + def http_query_params_only_operation( + self, + request: models.HttpQueryParamsOnlyOperationInput + | models.HttpQueryParamsOnlyOperationInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpQueryParamsOnlyOperationOutput: ... + + @overload + def http_query_params_only_operation( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpQueryParamsOnlyOperationInputDict], + ) -> models.HttpQueryParamsOnlyOperationOutput: + """ + This example tests httpQueryParams when no other query parameters exist. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_query_params_only_operation( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpQueryParamsOnlyOperationOutput: + return self._invoke( + self._select_input(models.HTTP_QUERY_PARAMS_ONLY_OPERATION, args, kwargs), + models.HTTP_QUERY_PARAMS_ONLY_OPERATION, + [], + plugins, + ) + + @overload + def http_request_with_float_labels( + self, + request: models.HttpRequestWithFloatLabelsInput + | models.HttpRequestWithFloatLabelsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithFloatLabelsOutput: ... + + @overload + def http_request_with_float_labels( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithFloatLabelsInputDict], + ) -> models.HttpRequestWithFloatLabelsOutput: + """ + Invokes the HttpRequestWithFloatLabels operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_request_with_float_labels( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithFloatLabelsOutput: + return self._invoke( + self._select_input(models.HTTP_REQUEST_WITH_FLOAT_LABELS, args, kwargs), + models.HTTP_REQUEST_WITH_FLOAT_LABELS, + [], + plugins, + ) + + @overload + def http_request_with_greedy_label_in_path( + self, + request: models.HttpRequestWithGreedyLabelInPathInput + | models.HttpRequestWithGreedyLabelInPathInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithGreedyLabelInPathOutput: ... + + @overload + def http_request_with_greedy_label_in_path( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithGreedyLabelInPathInputDict], + ) -> models.HttpRequestWithGreedyLabelInPathOutput: + """ + Invokes the HttpRequestWithGreedyLabelInPath operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_request_with_greedy_label_in_path( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithGreedyLabelInPathOutput: + return self._invoke( + self._select_input( + models.HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, args, kwargs + ), + models.HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH, + [], + plugins, + ) + + @overload + def http_request_with_labels( + self, + request: models.HttpRequestWithLabelsInput + | models.HttpRequestWithLabelsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithLabelsOutput: ... + + @overload + def http_request_with_labels( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithLabelsInputDict], + ) -> models.HttpRequestWithLabelsOutput: + """ + The example tests how requests are serialized when there's no input + payload but there are HTTP labels. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_request_with_labels( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithLabelsOutput: + return self._invoke( + self._select_input(models.HTTP_REQUEST_WITH_LABELS, args, kwargs), + models.HTTP_REQUEST_WITH_LABELS, + [], + plugins, + ) + + @overload + def http_request_with_labels_and_timestamp_format( + self, + request: models.HttpRequestWithLabelsAndTimestampFormatInput + | models.HttpRequestWithLabelsAndTimestampFormatInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithLabelsAndTimestampFormatOutput: ... + + @overload + def http_request_with_labels_and_timestamp_format( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithLabelsAndTimestampFormatInputDict], + ) -> models.HttpRequestWithLabelsAndTimestampFormatOutput: + """ + The example tests how requests serialize different timestamp formats in + the + URI path. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_request_with_labels_and_timestamp_format( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithLabelsAndTimestampFormatOutput: + return self._invoke( + self._select_input( + models.HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, args, kwargs + ), + models.HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT, + [], + plugins, + ) + + @overload + def http_request_with_regex_literal( + self, + request: models.HttpRequestWithRegexLiteralInput + | models.HttpRequestWithRegexLiteralInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpRequestWithRegexLiteralOutput: ... + + @overload + def http_request_with_regex_literal( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpRequestWithRegexLiteralInputDict], + ) -> models.HttpRequestWithRegexLiteralOutput: + """ + Invokes the HttpRequestWithRegexLiteral operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_request_with_regex_literal( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpRequestWithRegexLiteralOutput: + return self._invoke( + self._select_input(models.HTTP_REQUEST_WITH_REGEX_LITERAL, args, kwargs), + models.HTTP_REQUEST_WITH_REGEX_LITERAL, + [], + plugins, + ) + + @overload + def http_response_code( + self, + request: models.HttpResponseCodeInput | models.HttpResponseCodeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpResponseCodeOutput: ... + + @overload + def http_response_code( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpResponseCodeInputDict], + ) -> models.HttpResponseCodeOutput: + """ + Invokes the HttpResponseCode operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_response_code( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpResponseCodeOutput: + return self._invoke( + self._select_input(models.HTTP_RESPONSE_CODE, args, kwargs), + models.HTTP_RESPONSE_CODE, + [], + plugins, + ) + + @overload + def http_string_payload( + self, + request: models.HttpStringPayloadInput | models.HttpStringPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.HttpStringPayloadOutput: ... + + @overload + def http_string_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.HttpStringPayloadInputDict], + ) -> models.HttpStringPayloadOutput: + """ + Invokes the HttpStringPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def http_string_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.HttpStringPayloadOutput: + return self._invoke( + self._select_input(models.HTTP_STRING_PAYLOAD, args, kwargs), + models.HTTP_STRING_PAYLOAD, + [], + plugins, + ) + + @overload + def ignore_query_params_in_response( + self, + request: models.IgnoreQueryParamsInResponseInput + | models.IgnoreQueryParamsInResponseInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.IgnoreQueryParamsInResponseOutput: ... + + @overload + def ignore_query_params_in_response( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.IgnoreQueryParamsInResponseInputDict], + ) -> models.IgnoreQueryParamsInResponseOutput: + """ + This example ensures that query string bound request parameters are + serialized in the body of responses if the structure is used in both + the request and response. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def ignore_query_params_in_response( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.IgnoreQueryParamsInResponseOutput: + return self._invoke( + self._select_input(models.IGNORE_QUERY_PARAMS_IN_RESPONSE, args, kwargs), + models.IGNORE_QUERY_PARAMS_IN_RESPONSE, + [], + plugins, + ) + + @overload + def input_and_output_with_headers( + self, + request: models.InputAndOutputWithHeadersInput + | models.InputAndOutputWithHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.InputAndOutputWithHeadersOutput: ... + + @overload + def input_and_output_with_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.InputAndOutputWithHeadersInputDict], + ) -> models.InputAndOutputWithHeadersOutput: + """ + The example tests how requests and responses are serialized when there + is + no input or output payload but there are HTTP header bindings. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def input_and_output_with_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.InputAndOutputWithHeadersOutput: + return self._invoke( + self._select_input(models.INPUT_AND_OUTPUT_WITH_HEADERS, args, kwargs), + models.INPUT_AND_OUTPUT_WITH_HEADERS, + [], + plugins, + ) + + @overload + def json_blobs( + self, + request: models.JsonBlobsInput | models.JsonBlobsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonBlobsOutput: ... + + @overload + def json_blobs( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonBlobsInputDict], + ) -> models.JsonBlobsOutput: + """ + Blobs are base64 encoded + + :param plugins: Callables that change the configuration for this call + only. + """ + + def json_blobs( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonBlobsOutput: + return self._invoke( + self._select_input(models.JSON_BLOBS, args, kwargs), + models.JSON_BLOBS, + [], + plugins, + ) + + @overload + def json_enums( + self, + request: models.JsonEnumsInput | models.JsonEnumsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonEnumsOutput: ... + + @overload + def json_enums( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonEnumsInputDict], + ) -> models.JsonEnumsOutput: + """ + This example serializes enums as top level properties, in lists, sets, + and maps. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def json_enums( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonEnumsOutput: + return self._invoke( + self._select_input(models.JSON_ENUMS, args, kwargs), + models.JSON_ENUMS, + [], + plugins, + ) + + @overload + def json_int_enums( + self, + request: models.JsonIntEnumsInput | models.JsonIntEnumsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonIntEnumsOutput: ... + + @overload + def json_int_enums( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonIntEnumsInputDict], + ) -> models.JsonIntEnumsOutput: + """ + This example serializes intEnums as top level properties, in lists, + sets, and maps. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def json_int_enums( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonIntEnumsOutput: + return self._invoke( + self._select_input(models.JSON_INT_ENUMS, args, kwargs), + models.JSON_INT_ENUMS, + [], + plugins, + ) + + @overload + def json_lists( + self, + request: models.JsonListsInput | models.JsonListsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonListsOutput: ... + + @overload + def json_lists( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonListsInputDict], + ) -> models.JsonListsOutput: + """ + This test case serializes JSON lists for the following cases for both + input and output: + + 1. Normal JSON lists. + 2. Normal JSON sets. + 3. JSON lists of lists. + 4. Lists of structures. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def json_lists( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonListsOutput: + return self._invoke( + self._select_input(models.JSON_LISTS, args, kwargs), + models.JSON_LISTS, + [], + plugins, + ) + + @overload + def json_maps( + self, + request: models.JsonMapsInput | models.JsonMapsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonMapsOutput: ... + + @overload + def json_maps( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonMapsInputDict], + ) -> models.JsonMapsOutput: + """ + The example tests basic map serialization. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def json_maps( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonMapsOutput: + return self._invoke( + self._select_input(models.JSON_MAPS, args, kwargs), + models.JSON_MAPS, + [], + plugins, + ) + + @overload + def json_timestamps( + self, + request: models.JsonTimestampsInput | models.JsonTimestampsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonTimestampsOutput: ... + + @overload + def json_timestamps( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonTimestampsInputDict], + ) -> models.JsonTimestampsOutput: + """ + This tests how timestamps are serialized, including using the + default format of date-time and various @timestampFormat trait + values. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def json_timestamps( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonTimestampsOutput: + return self._invoke( + self._select_input(models.JSON_TIMESTAMPS, args, kwargs), + models.JSON_TIMESTAMPS, + [], + plugins, + ) + + @overload + def json_unions( + self, + request: models.JsonUnionsInput | models.JsonUnionsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.JsonUnionsOutput: ... + + @overload + def json_unions( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.JsonUnionsInputDict], + ) -> models.JsonUnionsOutput: + """ + This operation uses unions for inputs and outputs. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def json_unions( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.JsonUnionsOutput: + return self._invoke( + self._select_input(models.JSON_UNIONS, args, kwargs), + models.JSON_UNIONS, + [], + plugins, + ) + + @overload + def malformed_accept_with_body( + self, + request: models.MalformedAcceptWithBodyInput + | models.MalformedAcceptWithBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedAcceptWithBodyOutput: ... + + @overload + def malformed_accept_with_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedAcceptWithBodyInputDict], + ) -> models.MalformedAcceptWithBodyOutput: + """ + Invokes the MalformedAcceptWithBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_accept_with_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedAcceptWithBodyOutput: + return self._invoke( + self._select_input(models.MALFORMED_ACCEPT_WITH_BODY, args, kwargs), + models.MALFORMED_ACCEPT_WITH_BODY, + [], + plugins, + ) + + @overload + def malformed_accept_with_generic_string( + self, + request: models.MalformedAcceptWithGenericStringInput + | models.MalformedAcceptWithGenericStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedAcceptWithGenericStringOutput: ... + + @overload + def malformed_accept_with_generic_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedAcceptWithGenericStringInputDict], + ) -> models.MalformedAcceptWithGenericStringOutput: + """ + Invokes the MalformedAcceptWithGenericString operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_accept_with_generic_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedAcceptWithGenericStringOutput: + return self._invoke( + self._select_input( + models.MALFORMED_ACCEPT_WITH_GENERIC_STRING, args, kwargs + ), + models.MALFORMED_ACCEPT_WITH_GENERIC_STRING, + [], + plugins, + ) + + @overload + def malformed_accept_with_payload( + self, + request: models.MalformedAcceptWithPayloadInput + | models.MalformedAcceptWithPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedAcceptWithPayloadOutput: ... + + @overload + def malformed_accept_with_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedAcceptWithPayloadInputDict], + ) -> models.MalformedAcceptWithPayloadOutput: + """ + Invokes the MalformedAcceptWithPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_accept_with_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedAcceptWithPayloadOutput: + return self._invoke( + self._select_input(models.MALFORMED_ACCEPT_WITH_PAYLOAD, args, kwargs), + models.MALFORMED_ACCEPT_WITH_PAYLOAD, + [], + plugins, + ) + + @overload + def malformed_blob( + self, + request: models.MalformedBlobInput | models.MalformedBlobInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedBlobOutput: ... + + @overload + def malformed_blob( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedBlobInputDict], + ) -> models.MalformedBlobOutput: + """ + Invokes the MalformedBlob operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_blob( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedBlobOutput: + return self._invoke( + self._select_input(models.MALFORMED_BLOB, args, kwargs), + models.MALFORMED_BLOB, + [], + plugins, + ) + + @overload + def malformed_boolean( + self, + request: models.MalformedBooleanInput | models.MalformedBooleanInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedBooleanOutput: ... + + @overload + def malformed_boolean( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedBooleanInputDict], + ) -> models.MalformedBooleanOutput: + """ + Invokes the MalformedBoolean operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_boolean( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedBooleanOutput: + return self._invoke( + self._select_input(models.MALFORMED_BOOLEAN, args, kwargs), + models.MALFORMED_BOOLEAN, + [], + plugins, + ) + + @overload + def malformed_byte( + self, + request: models.MalformedByteInput | models.MalformedByteInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedByteOutput: ... + + @overload + def malformed_byte( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedByteInputDict], + ) -> models.MalformedByteOutput: + """ + Invokes the MalformedByte operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_byte( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedByteOutput: + return self._invoke( + self._select_input(models.MALFORMED_BYTE, args, kwargs), + models.MALFORMED_BYTE, + [], + plugins, + ) + + @overload + def malformed_content_type_with_body( + self, + request: models.MalformedContentTypeWithBodyInput + | models.MalformedContentTypeWithBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithBodyOutput: ... + + @overload + def malformed_content_type_with_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithBodyInputDict], + ) -> models.MalformedContentTypeWithBodyOutput: + """ + Invokes the MalformedContentTypeWithBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_content_type_with_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithBodyOutput: + return self._invoke( + self._select_input(models.MALFORMED_CONTENT_TYPE_WITH_BODY, args, kwargs), + models.MALFORMED_CONTENT_TYPE_WITH_BODY, + [], + plugins, + ) + + @overload + def malformed_content_type_with_generic_string( + self, + request: models.MalformedContentTypeWithGenericStringInput + | models.MalformedContentTypeWithGenericStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithGenericStringOutput: ... + + @overload + def malformed_content_type_with_generic_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithGenericStringInputDict], + ) -> models.MalformedContentTypeWithGenericStringOutput: + """ + Invokes the MalformedContentTypeWithGenericString operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_content_type_with_generic_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithGenericStringOutput: + return self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING, + [], + plugins, + ) + + @overload + def malformed_content_type_with_payload( + self, + request: models.MalformedContentTypeWithPayloadInput + | models.MalformedContentTypeWithPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithPayloadOutput: ... + + @overload + def malformed_content_type_with_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithPayloadInputDict], + ) -> models.MalformedContentTypeWithPayloadOutput: + """ + Invokes the MalformedContentTypeWithPayload operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_content_type_with_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithPayloadOutput: + return self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITH_PAYLOAD, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITH_PAYLOAD, + [], + plugins, + ) + + @overload + def malformed_content_type_without_body( + self, + request: models.MalformedContentTypeWithoutBodyInput + | models.MalformedContentTypeWithoutBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithoutBodyOutput: ... + + @overload + def malformed_content_type_without_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithoutBodyInputDict], + ) -> models.MalformedContentTypeWithoutBodyOutput: + """ + Invokes the MalformedContentTypeWithoutBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_content_type_without_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithoutBodyOutput: + return self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY, + [], + plugins, + ) + + @overload + def malformed_content_type_without_body_empty_input( + self, + request: models.MalformedContentTypeWithoutBodyEmptyInputInput + | models.MalformedContentTypeWithoutBodyEmptyInputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedContentTypeWithoutBodyEmptyInputOutput: ... + + @overload + def malformed_content_type_without_body_empty_input( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedContentTypeWithoutBodyEmptyInputInputDict], + ) -> models.MalformedContentTypeWithoutBodyEmptyInputOutput: + """ + Invokes the MalformedContentTypeWithoutBodyEmptyInput operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_content_type_without_body_empty_input( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedContentTypeWithoutBodyEmptyInputOutput: + return self._invoke( + self._select_input( + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT, args, kwargs + ), + models.MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT, + [], + plugins, + ) + + @overload + def malformed_double( + self, + request: models.MalformedDoubleInput | models.MalformedDoubleInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedDoubleOutput: ... + + @overload + def malformed_double( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedDoubleInputDict], + ) -> models.MalformedDoubleOutput: + """ + Invokes the MalformedDouble operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_double( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedDoubleOutput: + return self._invoke( + self._select_input(models.MALFORMED_DOUBLE, args, kwargs), + models.MALFORMED_DOUBLE, + [], + plugins, + ) + + @overload + def malformed_float( + self, + request: models.MalformedFloatInput | models.MalformedFloatInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedFloatOutput: ... + + @overload + def malformed_float( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedFloatInputDict], + ) -> models.MalformedFloatOutput: + """ + Invokes the MalformedFloat operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_float( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedFloatOutput: + return self._invoke( + self._select_input(models.MALFORMED_FLOAT, args, kwargs), + models.MALFORMED_FLOAT, + [], + plugins, + ) + + @overload + def malformed_integer( + self, + request: models.MalformedIntegerInput | models.MalformedIntegerInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedIntegerOutput: ... + + @overload + def malformed_integer( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedIntegerInputDict], + ) -> models.MalformedIntegerOutput: + """ + Invokes the MalformedInteger operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_integer( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedIntegerOutput: + return self._invoke( + self._select_input(models.MALFORMED_INTEGER, args, kwargs), + models.MALFORMED_INTEGER, + [], + plugins, + ) + + @overload + def malformed_list( + self, + request: models.MalformedListInput | models.MalformedListInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedListOutput: ... + + @overload + def malformed_list( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedListInputDict], + ) -> models.MalformedListOutput: + """ + Invokes the MalformedList operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_list( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedListOutput: + return self._invoke( + self._select_input(models.MALFORMED_LIST, args, kwargs), + models.MALFORMED_LIST, + [], + plugins, + ) + + @overload + def malformed_long( + self, + request: models.MalformedLongInput | models.MalformedLongInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedLongOutput: ... + + @overload + def malformed_long( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedLongInputDict], + ) -> models.MalformedLongOutput: + """ + Invokes the MalformedLong operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_long( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedLongOutput: + return self._invoke( + self._select_input(models.MALFORMED_LONG, args, kwargs), + models.MALFORMED_LONG, + [], + plugins, + ) + + @overload + def malformed_map( + self, + request: models.MalformedMapInput | models.MalformedMapInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedMapOutput: ... + + @overload + def malformed_map( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedMapInputDict], + ) -> models.MalformedMapOutput: + """ + Invokes the MalformedMap operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_map( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedMapOutput: + return self._invoke( + self._select_input(models.MALFORMED_MAP, args, kwargs), + models.MALFORMED_MAP, + [], + plugins, + ) + + @overload + def malformed_request_body( + self, + request: models.MalformedRequestBodyInput + | models.MalformedRequestBodyInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedRequestBodyOutput: ... + + @overload + def malformed_request_body( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedRequestBodyInputDict], + ) -> models.MalformedRequestBodyOutput: + """ + Invokes the MalformedRequestBody operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_request_body( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedRequestBodyOutput: + return self._invoke( + self._select_input(models.MALFORMED_REQUEST_BODY, args, kwargs), + models.MALFORMED_REQUEST_BODY, + [], + plugins, + ) + + @overload + def malformed_short( + self, + request: models.MalformedShortInput | models.MalformedShortInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedShortOutput: ... + + @overload + def malformed_short( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedShortInputDict], + ) -> models.MalformedShortOutput: + """ + Invokes the MalformedShort operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_short( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedShortOutput: + return self._invoke( + self._select_input(models.MALFORMED_SHORT, args, kwargs), + models.MALFORMED_SHORT, + [], + plugins, + ) + + @overload + def malformed_string( + self, + request: models.MalformedStringInput | models.MalformedStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedStringOutput: ... + + @overload + def malformed_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedStringInputDict], + ) -> models.MalformedStringOutput: + """ + Invokes the MalformedString operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedStringOutput: + return self._invoke( + self._select_input(models.MALFORMED_STRING, args, kwargs), + models.MALFORMED_STRING, + [], + plugins, + ) + + @overload + def malformed_timestamp_body_date_time( + self, + request: models.MalformedTimestampBodyDateTimeInput + | models.MalformedTimestampBodyDateTimeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampBodyDateTimeOutput: ... + + @overload + def malformed_timestamp_body_date_time( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampBodyDateTimeInputDict], + ) -> models.MalformedTimestampBodyDateTimeOutput: + """ + Invokes the MalformedTimestampBodyDateTime operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_body_date_time( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampBodyDateTimeOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_BODY_DATE_TIME, args, kwargs), + models.MALFORMED_TIMESTAMP_BODY_DATE_TIME, + [], + plugins, + ) + + @overload + def malformed_timestamp_body_default( + self, + request: models.MalformedTimestampBodyDefaultInput + | models.MalformedTimestampBodyDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampBodyDefaultOutput: ... + + @overload + def malformed_timestamp_body_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampBodyDefaultInputDict], + ) -> models.MalformedTimestampBodyDefaultOutput: + """ + Invokes the MalformedTimestampBodyDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_body_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampBodyDefaultOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_BODY_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_BODY_DEFAULT, + [], + plugins, + ) + + @overload + def malformed_timestamp_body_http_date( + self, + request: models.MalformedTimestampBodyHttpDateInput + | models.MalformedTimestampBodyHttpDateInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampBodyHttpDateOutput: ... + + @overload + def malformed_timestamp_body_http_date( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampBodyHttpDateInputDict], + ) -> models.MalformedTimestampBodyHttpDateOutput: + """ + Invokes the MalformedTimestampBodyHttpDate operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_body_http_date( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampBodyHttpDateOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_BODY_HTTP_DATE, args, kwargs), + models.MALFORMED_TIMESTAMP_BODY_HTTP_DATE, + [], + plugins, + ) + + @overload + def malformed_timestamp_header_date_time( + self, + request: models.MalformedTimestampHeaderDateTimeInput + | models.MalformedTimestampHeaderDateTimeInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampHeaderDateTimeOutput: ... + + @overload + def malformed_timestamp_header_date_time( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampHeaderDateTimeInputDict], + ) -> models.MalformedTimestampHeaderDateTimeOutput: + """ + Invokes the MalformedTimestampHeaderDateTime operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_header_date_time( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampHeaderDateTimeOutput: + return self._invoke( + self._select_input( + models.MALFORMED_TIMESTAMP_HEADER_DATE_TIME, args, kwargs + ), + models.MALFORMED_TIMESTAMP_HEADER_DATE_TIME, + [], + plugins, + ) + + @overload + def malformed_timestamp_header_default( + self, + request: models.MalformedTimestampHeaderDefaultInput + | models.MalformedTimestampHeaderDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampHeaderDefaultOutput: ... + + @overload + def malformed_timestamp_header_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampHeaderDefaultInputDict], + ) -> models.MalformedTimestampHeaderDefaultOutput: + """ + Invokes the MalformedTimestampHeaderDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_header_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampHeaderDefaultOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_HEADER_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_HEADER_DEFAULT, + [], + plugins, + ) + + @overload + def malformed_timestamp_header_epoch( + self, + request: models.MalformedTimestampHeaderEpochInput + | models.MalformedTimestampHeaderEpochInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampHeaderEpochOutput: ... + + @overload + def malformed_timestamp_header_epoch( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampHeaderEpochInputDict], + ) -> models.MalformedTimestampHeaderEpochOutput: + """ + Invokes the MalformedTimestampHeaderEpoch operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_header_epoch( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampHeaderEpochOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_HEADER_EPOCH, args, kwargs), + models.MALFORMED_TIMESTAMP_HEADER_EPOCH, + [], + plugins, + ) + + @overload + def malformed_timestamp_path_default( + self, + request: models.MalformedTimestampPathDefaultInput + | models.MalformedTimestampPathDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampPathDefaultOutput: ... + + @overload + def malformed_timestamp_path_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampPathDefaultInputDict], + ) -> models.MalformedTimestampPathDefaultOutput: + """ + Invokes the MalformedTimestampPathDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_path_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampPathDefaultOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_PATH_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_PATH_DEFAULT, + [], + plugins, + ) + + @overload + def malformed_timestamp_path_epoch( + self, + request: models.MalformedTimestampPathEpochInput + | models.MalformedTimestampPathEpochInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampPathEpochOutput: ... + + @overload + def malformed_timestamp_path_epoch( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampPathEpochInputDict], + ) -> models.MalformedTimestampPathEpochOutput: + """ + Invokes the MalformedTimestampPathEpoch operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_path_epoch( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampPathEpochOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_PATH_EPOCH, args, kwargs), + models.MALFORMED_TIMESTAMP_PATH_EPOCH, + [], + plugins, + ) + + @overload + def malformed_timestamp_path_http_date( + self, + request: models.MalformedTimestampPathHttpDateInput + | models.MalformedTimestampPathHttpDateInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampPathHttpDateOutput: ... + + @overload + def malformed_timestamp_path_http_date( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampPathHttpDateInputDict], + ) -> models.MalformedTimestampPathHttpDateOutput: + """ + Invokes the MalformedTimestampPathHttpDate operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_path_http_date( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampPathHttpDateOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_PATH_HTTP_DATE, args, kwargs), + models.MALFORMED_TIMESTAMP_PATH_HTTP_DATE, + [], + plugins, + ) + + @overload + def malformed_timestamp_query_default( + self, + request: models.MalformedTimestampQueryDefaultInput + | models.MalformedTimestampQueryDefaultInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampQueryDefaultOutput: ... + + @overload + def malformed_timestamp_query_default( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampQueryDefaultInputDict], + ) -> models.MalformedTimestampQueryDefaultOutput: + """ + Invokes the MalformedTimestampQueryDefault operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_query_default( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampQueryDefaultOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_QUERY_DEFAULT, args, kwargs), + models.MALFORMED_TIMESTAMP_QUERY_DEFAULT, + [], + plugins, + ) + + @overload + def malformed_timestamp_query_epoch( + self, + request: models.MalformedTimestampQueryEpochInput + | models.MalformedTimestampQueryEpochInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampQueryEpochOutput: ... + + @overload + def malformed_timestamp_query_epoch( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampQueryEpochInputDict], + ) -> models.MalformedTimestampQueryEpochOutput: + """ + Invokes the MalformedTimestampQueryEpoch operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_query_epoch( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampQueryEpochOutput: + return self._invoke( + self._select_input(models.MALFORMED_TIMESTAMP_QUERY_EPOCH, args, kwargs), + models.MALFORMED_TIMESTAMP_QUERY_EPOCH, + [], + plugins, + ) + + @overload + def malformed_timestamp_query_http_date( + self, + request: models.MalformedTimestampQueryHttpDateInput + | models.MalformedTimestampQueryHttpDateInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedTimestampQueryHttpDateOutput: ... + + @overload + def malformed_timestamp_query_http_date( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedTimestampQueryHttpDateInputDict], + ) -> models.MalformedTimestampQueryHttpDateOutput: + """ + Invokes the MalformedTimestampQueryHttpDate operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_timestamp_query_http_date( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedTimestampQueryHttpDateOutput: + return self._invoke( + self._select_input( + models.MALFORMED_TIMESTAMP_QUERY_HTTP_DATE, args, kwargs + ), + models.MALFORMED_TIMESTAMP_QUERY_HTTP_DATE, + [], + plugins, + ) + + @overload + def malformed_union( + self, + request: models.MalformedUnionInput | models.MalformedUnionInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MalformedUnionOutput: ... + + @overload + def malformed_union( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MalformedUnionInputDict], + ) -> models.MalformedUnionOutput: + """ + Invokes the MalformedUnion operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def malformed_union( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MalformedUnionOutput: + return self._invoke( + self._select_input(models.MALFORMED_UNION, args, kwargs), + models.MALFORMED_UNION, + [], + plugins, + ) + + @overload + def media_type_header( + self, + request: models.MediaTypeHeaderInput | models.MediaTypeHeaderInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.MediaTypeHeaderOutput: ... + + @overload + def media_type_header( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.MediaTypeHeaderInputDict], + ) -> models.MediaTypeHeaderOutput: + """ + This example ensures that mediaType strings are base64 encoded in + headers. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def media_type_header( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.MediaTypeHeaderOutput: + return self._invoke( + self._select_input(models.MEDIA_TYPE_HEADER, args, kwargs), + models.MEDIA_TYPE_HEADER, + [], + plugins, + ) + + @overload + def no_input_and_no_output( + self, + request: models.NoInputAndNoOutputInput | models.NoInputAndNoOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NoInputAndNoOutputOutput: ... + + @overload + def no_input_and_no_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NoInputAndNoOutputInputDict], + ) -> models.NoInputAndNoOutputOutput: + """ + The example tests how requests and responses are serialized when there's + no request or response payload because the operation has no input or + output. + While this should be rare, code generators must support this. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def no_input_and_no_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NoInputAndNoOutputOutput: + return self._invoke( + self._select_input(models.NO_INPUT_AND_NO_OUTPUT, args, kwargs), + models.NO_INPUT_AND_NO_OUTPUT, + [], + plugins, + ) + + @overload + def no_input_and_output( + self, + request: models.NoInputAndOutputInput | models.NoInputAndOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NoInputAndOutputOutput: ... + + @overload + def no_input_and_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NoInputAndOutputInputDict], + ) -> models.NoInputAndOutputOutput: + """ + The example tests how requests and responses are serialized when there's + no request or response payload because the operation has no input and + the + output is empty. While this should be rare, code generators must support + this. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def no_input_and_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NoInputAndOutputOutput: + return self._invoke( + self._select_input(models.NO_INPUT_AND_OUTPUT, args, kwargs), + models.NO_INPUT_AND_OUTPUT, + [], + plugins, + ) + + @overload + def null_and_empty_headers_client( + self, + request: models.NullAndEmptyHeadersClientInput + | models.NullAndEmptyHeadersClientInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NullAndEmptyHeadersClientOutput: ... + + @overload + def null_and_empty_headers_client( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NullAndEmptyHeadersClientInputDict], + ) -> models.NullAndEmptyHeadersClientOutput: + """ + Null headers are not sent over the wire, empty headers are serialized to + "" + + :param plugins: Callables that change the configuration for this call + only. + """ + + def null_and_empty_headers_client( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NullAndEmptyHeadersClientOutput: + return self._invoke( + self._select_input(models.NULL_AND_EMPTY_HEADERS_CLIENT, args, kwargs), + models.NULL_AND_EMPTY_HEADERS_CLIENT, + [], + plugins, + ) + + @overload + def null_and_empty_headers_server( + self, + request: models.NullAndEmptyHeadersServerInput + | models.NullAndEmptyHeadersServerInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.NullAndEmptyHeadersServerOutput: ... + + @overload + def null_and_empty_headers_server( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.NullAndEmptyHeadersServerInputDict], + ) -> models.NullAndEmptyHeadersServerOutput: + """ + Null headers are not sent over the wire, empty headers are serialized to + "" + + :param plugins: Callables that change the configuration for this call + only. + """ + + def null_and_empty_headers_server( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.NullAndEmptyHeadersServerOutput: + return self._invoke( + self._select_input(models.NULL_AND_EMPTY_HEADERS_SERVER, args, kwargs), + models.NULL_AND_EMPTY_HEADERS_SERVER, + [], + plugins, + ) + + @overload + def omits_null_serializes_empty_string( + self, + request: models.OmitsNullSerializesEmptyStringInput + | models.OmitsNullSerializesEmptyStringInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OmitsNullSerializesEmptyStringOutput: ... + + @overload + def omits_null_serializes_empty_string( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OmitsNullSerializesEmptyStringInputDict], + ) -> models.OmitsNullSerializesEmptyStringOutput: + """ + Omits null, but serializes empty string value. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def omits_null_serializes_empty_string( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OmitsNullSerializesEmptyStringOutput: + return self._invoke( + self._select_input(models.OMITS_NULL_SERIALIZES_EMPTY_STRING, args, kwargs), + models.OMITS_NULL_SERIALIZES_EMPTY_STRING, + [], + plugins, + ) + + @overload + def omits_serializing_empty_lists( + self, + request: models.OmitsSerializingEmptyListsInput + | models.OmitsSerializingEmptyListsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OmitsSerializingEmptyListsOutput: ... + + @overload + def omits_serializing_empty_lists( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OmitsSerializingEmptyListsInputDict], + ) -> models.OmitsSerializingEmptyListsOutput: + """ + Omits serializing empty lists. Because empty strings are serilized as + `Foo=`, empty lists cannot also be serialized as `Foo=` and instead + must be omitted. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def omits_serializing_empty_lists( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OmitsSerializingEmptyListsOutput: + return self._invoke( + self._select_input(models.OMITS_SERIALIZING_EMPTY_LISTS, args, kwargs), + models.OMITS_SERIALIZING_EMPTY_LISTS, + [], + plugins, + ) + + @overload + def operation_with_defaults( + self, + request: models.OperationWithDefaultsInput + | models.OperationWithDefaultsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OperationWithDefaultsOutput: ... + + @overload + def operation_with_defaults( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OperationWithDefaultsInputDict], + ) -> models.OperationWithDefaultsOutput: + """ + Invokes the OperationWithDefaults operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def operation_with_defaults( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OperationWithDefaultsOutput: + return self._invoke( + self._select_input(models.OPERATION_WITH_DEFAULTS, args, kwargs), + models.OPERATION_WITH_DEFAULTS, + [], + plugins, + ) + + @overload + def operation_with_nested_structure( + self, + request: models.OperationWithNestedStructureInput + | models.OperationWithNestedStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.OperationWithNestedStructureOutput: ... + + @overload + def operation_with_nested_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.OperationWithNestedStructureInputDict], + ) -> models.OperationWithNestedStructureOutput: + """ + Invokes the OperationWithNestedStructure operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def operation_with_nested_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.OperationWithNestedStructureOutput: + return self._invoke( + self._select_input(models.OPERATION_WITH_NESTED_STRUCTURE, args, kwargs), + models.OPERATION_WITH_NESTED_STRUCTURE, + [], + plugins, + ) + + @overload + def post_player_action( + self, + request: models.PostPlayerActionInput | models.PostPlayerActionInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.PostPlayerActionOutput: ... + + @overload + def post_player_action( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.PostPlayerActionInputDict], + ) -> models.PostPlayerActionOutput: + """ + This operation defines a union with a Unit member. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def post_player_action( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.PostPlayerActionOutput: + return self._invoke( + self._select_input(models.POST_PLAYER_ACTION, args, kwargs), + models.POST_PLAYER_ACTION, + [], + plugins, + ) + + @overload + def post_union_with_json_name( + self, + request: models.PostUnionWithJsonNameInput + | models.PostUnionWithJsonNameInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.PostUnionWithJsonNameOutput: ... + + @overload + def post_union_with_json_name( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.PostUnionWithJsonNameInputDict], + ) -> models.PostUnionWithJsonNameOutput: + """ + This operation defines a union that uses jsonName on some members. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def post_union_with_json_name( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.PostUnionWithJsonNameOutput: + return self._invoke( + self._select_input(models.POST_UNION_WITH_JSON_NAME, args, kwargs), + models.POST_UNION_WITH_JSON_NAME, + [], + plugins, + ) + + @overload + def put_with_content_encoding( + self, + request: models.PutWithContentEncodingInput + | models.PutWithContentEncodingInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.PutWithContentEncodingOutput: ... + + @overload + def put_with_content_encoding( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.PutWithContentEncodingInputDict], + ) -> models.PutWithContentEncodingOutput: + """ + Invokes the PutWithContentEncoding operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def put_with_content_encoding( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.PutWithContentEncodingOutput: + return self._invoke( + self._select_input(models.PUT_WITH_CONTENT_ENCODING, args, kwargs), + models.PUT_WITH_CONTENT_ENCODING, + [], + plugins, + ) + + @overload + def query_idempotency_token_auto_fill( + self, + request: models.QueryIdempotencyTokenAutoFillInput + | models.QueryIdempotencyTokenAutoFillInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.QueryIdempotencyTokenAutoFillOutput: ... + + @overload + def query_idempotency_token_auto_fill( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.QueryIdempotencyTokenAutoFillInputDict], + ) -> models.QueryIdempotencyTokenAutoFillOutput: + """ + Automatically adds idempotency tokens. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def query_idempotency_token_auto_fill( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.QueryIdempotencyTokenAutoFillOutput: + return self._invoke( + self._select_input(models.QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, args, kwargs), + models.QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL, + [], + plugins, + ) + + @overload + def query_params_as_string_list_map( + self, + request: models.QueryParamsAsStringListMapInput + | models.QueryParamsAsStringListMapInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.QueryParamsAsStringListMapOutput: ... + + @overload + def query_params_as_string_list_map( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.QueryParamsAsStringListMapInputDict], + ) -> models.QueryParamsAsStringListMapOutput: + """ + Invokes the QueryParamsAsStringListMap operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def query_params_as_string_list_map( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.QueryParamsAsStringListMapOutput: + return self._invoke( + self._select_input(models.QUERY_PARAMS_AS_STRING_LIST_MAP, args, kwargs), + models.QUERY_PARAMS_AS_STRING_LIST_MAP, + [], + plugins, + ) + + @overload + def query_precedence( + self, + request: models.QueryPrecedenceInput | models.QueryPrecedenceInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.QueryPrecedenceOutput: ... + + @overload + def query_precedence( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.QueryPrecedenceInputDict], + ) -> models.QueryPrecedenceOutput: + """ + Invokes the QueryPrecedence operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def query_precedence( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.QueryPrecedenceOutput: + return self._invoke( + self._select_input(models.QUERY_PRECEDENCE, args, kwargs), + models.QUERY_PRECEDENCE, + [], + plugins, + ) + + @overload + def recursive_shapes( + self, + request: models.RecursiveShapesInput | models.RecursiveShapesInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.RecursiveShapesOutput: ... + + @overload + def recursive_shapes( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.RecursiveShapesInputDict], + ) -> models.RecursiveShapesOutput: + """ + Recursive shapes + + :param plugins: Callables that change the configuration for this call + only. + """ + + def recursive_shapes( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.RecursiveShapesOutput: + return self._invoke( + self._select_input(models.RECURSIVE_SHAPES, args, kwargs), + models.RECURSIVE_SHAPES, + [], + plugins, + ) + + @overload + def response_code_http_fallback( + self, + request: models.ResponseCodeHttpFallbackInput + | models.ResponseCodeHttpFallbackInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ResponseCodeHttpFallbackOutput: ... + + @overload + def response_code_http_fallback( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ResponseCodeHttpFallbackInputDict], + ) -> models.ResponseCodeHttpFallbackOutput: + """ + Invokes the ResponseCodeHttpFallback operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def response_code_http_fallback( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ResponseCodeHttpFallbackOutput: + return self._invoke( + self._select_input(models.RESPONSE_CODE_HTTP_FALLBACK, args, kwargs), + models.RESPONSE_CODE_HTTP_FALLBACK, + [], + plugins, + ) + + @overload + def response_code_required( + self, + request: models.ResponseCodeRequiredInput + | models.ResponseCodeRequiredInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.ResponseCodeRequiredOutput: ... + + @overload + def response_code_required( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.ResponseCodeRequiredInputDict], + ) -> models.ResponseCodeRequiredOutput: + """ + Invokes the ResponseCodeRequired operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def response_code_required( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.ResponseCodeRequiredOutput: + return self._invoke( + self._select_input(models.RESPONSE_CODE_REQUIRED, args, kwargs), + models.RESPONSE_CODE_REQUIRED, + [], + plugins, + ) + + @overload + def simple_scalar_properties( + self, + request: models.SimpleScalarPropertiesInput + | models.SimpleScalarPropertiesInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.SimpleScalarPropertiesOutput: ... + + @overload + def simple_scalar_properties( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.SimpleScalarPropertiesInputDict], + ) -> models.SimpleScalarPropertiesOutput: + """ + Invokes the SimpleScalarProperties operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def simple_scalar_properties( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.SimpleScalarPropertiesOutput: + return self._invoke( + self._select_input(models.SIMPLE_SCALAR_PROPERTIES, args, kwargs), + models.SIMPLE_SCALAR_PROPERTIES, + [], + plugins, + ) + + @overload + def sparse_json_lists( + self, + request: models.SparseJsonListsInput | models.SparseJsonListsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.SparseJsonListsOutput: ... + + @overload + def sparse_json_lists( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.SparseJsonListsInputDict], + ) -> models.SparseJsonListsOutput: + """ + Invokes the SparseJsonLists operation. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def sparse_json_lists( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.SparseJsonListsOutput: + return self._invoke( + self._select_input(models.SPARSE_JSON_LISTS, args, kwargs), + models.SPARSE_JSON_LISTS, + [], + plugins, + ) + + @overload + def sparse_json_maps( + self, + request: models.SparseJsonMapsInput | models.SparseJsonMapsInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.SparseJsonMapsOutput: ... + + @overload + def sparse_json_maps( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.SparseJsonMapsInputDict], + ) -> models.SparseJsonMapsOutput: + """ + This example tests sparse map serialization. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def sparse_json_maps( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.SparseJsonMapsOutput: + return self._invoke( + self._select_input(models.SPARSE_JSON_MAPS, args, kwargs), + models.SPARSE_JSON_MAPS, + [], + plugins, + ) + + @overload + def test_body_structure( + self, + request: models.TestBodyStructureInput | models.TestBodyStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestBodyStructureOutput: ... + + @overload + def test_body_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestBodyStructureInputDict], + ) -> models.TestBodyStructureOutput: + """ + This example operation serializes a structure in the HTTP body. + + It should ensure Content-Type: application/json is + used in all requests and that an "empty" body is + an empty JSON document ({}). + + + :param plugins: Callables that change the configuration for this call + only. + """ + + def test_body_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestBodyStructureOutput: + return self._invoke( + self._select_input(models.TEST_BODY_STRUCTURE, args, kwargs), + models.TEST_BODY_STRUCTURE, + [], + plugins, + ) + + @overload + def test_get_no_input_no_payload( + self, + request: models.TestGetNoInputNoPayloadInput + | models.TestGetNoInputNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestGetNoInputNoPayloadOutput: ... + + @overload + def test_get_no_input_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestGetNoInputNoPayloadInputDict], + ) -> models.TestGetNoInputNoPayloadOutput: + """ + This example GET operation has no input and serializes a request without + a HTTP body. + + These tests are to ensure we do not attach a body or related headers + (Content-Length, Content-Type) to operations that semantically + cannot produce an HTTP body. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + def test_get_no_input_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestGetNoInputNoPayloadOutput: + return self._invoke( + self._select_input(models.TEST_GET_NO_INPUT_NO_PAYLOAD, args, kwargs), + models.TEST_GET_NO_INPUT_NO_PAYLOAD, + [], + plugins, + ) + + @overload + def test_get_no_payload( + self, + request: models.TestGetNoPayloadInput | models.TestGetNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestGetNoPayloadOutput: ... + + @overload + def test_get_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestGetNoPayloadInputDict], + ) -> models.TestGetNoPayloadOutput: + """ + This example GET operation serializes a request without a modeled HTTP + body. + + These tests are to ensure we do not attach a body or related headers + (Content-Length, Content-Type) to operations that semantically + cannot produce an HTTP body. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + def test_get_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestGetNoPayloadOutput: + return self._invoke( + self._select_input(models.TEST_GET_NO_PAYLOAD, args, kwargs), + models.TEST_GET_NO_PAYLOAD, + [], + plugins, + ) + + @overload + def test_payload_blob( + self, + request: models.TestPayloadBlobInput | models.TestPayloadBlobInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPayloadBlobOutput: ... + + @overload + def test_payload_blob( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPayloadBlobInputDict], + ) -> models.TestPayloadBlobOutput: + """ + This example operation serializes a payload targeting a blob. + + The Blob shape is not structured content and we cannot + make assumptions about what data will be sent. This test ensures + only a generic "Content-Type: application/octet-stream" header + is used, and that we are not treating an empty body as an + empty JSON document. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + def test_payload_blob( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPayloadBlobOutput: + return self._invoke( + self._select_input(models.TEST_PAYLOAD_BLOB, args, kwargs), + models.TEST_PAYLOAD_BLOB, + [], + plugins, + ) + + @overload + def test_payload_structure( + self, + request: models.TestPayloadStructureInput + | models.TestPayloadStructureInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPayloadStructureOutput: ... + + @overload + def test_payload_structure( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPayloadStructureInputDict], + ) -> models.TestPayloadStructureOutput: + """ + This example operation serializes a payload targeting a structure. + + This enforces the same requirements as TestBodyStructure + but with the body specified by the @httpPayload trait. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + def test_payload_structure( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPayloadStructureOutput: + return self._invoke( + self._select_input(models.TEST_PAYLOAD_STRUCTURE, args, kwargs), + models.TEST_PAYLOAD_STRUCTURE, + [], + plugins, + ) + + @overload + def test_post_no_input_no_payload( + self, + request: models.TestPostNoInputNoPayloadInput + | models.TestPostNoInputNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPostNoInputNoPayloadOutput: ... + + @overload + def test_post_no_input_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPostNoInputNoPayloadInputDict], + ) -> models.TestPostNoInputNoPayloadOutput: + """ + This example POST operation has no input and serializes a request + without a HTTP body. + + These tests are to ensure we do not attach a body or related headers + (Content-Type) to a POST operation with no modeled input. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + def test_post_no_input_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPostNoInputNoPayloadOutput: + return self._invoke( + self._select_input(models.TEST_POST_NO_INPUT_NO_PAYLOAD, args, kwargs), + models.TEST_POST_NO_INPUT_NO_PAYLOAD, + [], + plugins, + ) + + @overload + def test_post_no_payload( + self, + request: models.TestPostNoPayloadInput | models.TestPostNoPayloadInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TestPostNoPayloadOutput: ... + + @overload + def test_post_no_payload( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TestPostNoPayloadInputDict], + ) -> models.TestPostNoPayloadOutput: + """ + This example POST operation serializes a request without a modeled HTTP + body. + + These tests are to ensure we do not attach a body or related headers + (Content-Type) to a POST operation with no modeled payload. + + + :param plugins: Callables that change the configuration for this call + only. + """ + + def test_post_no_payload( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TestPostNoPayloadOutput: + return self._invoke( + self._select_input(models.TEST_POST_NO_PAYLOAD, args, kwargs), + models.TEST_POST_NO_PAYLOAD, + [], + plugins, + ) + + @overload + def timestamp_format_headers( + self, + request: models.TimestampFormatHeadersInput + | models.TimestampFormatHeadersInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.TimestampFormatHeadersOutput: ... + + @overload + def timestamp_format_headers( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.TimestampFormatHeadersInputDict], + ) -> models.TimestampFormatHeadersOutput: + """ + This example tests how timestamp request and response headers are + serialized. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def timestamp_format_headers( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.TimestampFormatHeadersOutput: + return self._invoke( + self._select_input(models.TIMESTAMP_FORMAT_HEADERS, args, kwargs), + models.TIMESTAMP_FORMAT_HEADERS, + [], + plugins, + ) + + @overload + def unit_input_and_output( + self, + request: models.UnitInputAndOutputInput | models.UnitInputAndOutputInputDict, + /, + *, + plugins: list[Plugin] | None = None, + ) -> models.UnitInputAndOutputOutput: ... + + @overload + def unit_input_and_output( + self, + /, + *, + plugins: list[Plugin] | None = None, + **kwargs: Unpack[models.UnitInputAndOutputInputDict], + ) -> models.UnitInputAndOutputOutput: + """ + This test is similar to NoInputAndNoOutput, but uses explicit Unit + types. + + :param plugins: Callables that change the configuration for this call + only. + """ + + def unit_input_and_output( + self, /, *args: object, plugins: list[Plugin] | None = None, **kwargs: object + ) -> models.UnitInputAndOutputOutput: + return self._invoke( + self._select_input(models.UNIT_INPUT_AND_OUTPUT, args, kwargs), + models.UNIT_INPUT_AND_OUTPUT, + [], + plugins, + ) + + def _new_config(self) -> RestJsonProtocolConfig: + return RestJsonProtocolConfig.resolve() + + def _post_setup(self, config: RestJsonProtocolConfig) -> None: + if config.aws_credentials_identity_resolver is None: + config_context = config.resolution_context() + config_file = None + profile_name = None + if config_context is not None: + config_file = config_context.parsed_profiles() + if config_context.profile_source is ConfigSource.OVERRIDE: + profile_name = config_context.profile_name + config.aws_credentials_identity_resolver = IdentityChain.create( + AWSCredentialsIdentity, + config_file=config_file, + profile_name=profile_name, + region_override=config.region, + http_client=cast(HTTPClient | None, config.transport), + ) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/config.py b/codegen-output-py/rest-json-1-client/src/restjson_client/config.py new file mode 100644 index 000000000..dfbb21836 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/config.py @@ -0,0 +1,118 @@ +from collections.abc import Callable +from dataclasses import dataclass, field +from typing import Any, ClassVar, Self, Unpack + +from smithy_aws_core.auth.sigv4 import SigV4AuthScheme +from smithy_aws_core.config.aws_config import AwsConfig, AwsConfigOverrides +from smithy_aws_core.config.filesystem import FileSystem +from smithy_aws_core.config.resolvers import EndpointUriResolver +from smithy_aws_core.config.types import FieldSpec +from smithy_aws_core.endpoints import AWS_RULES_EXTENSION +from smithy_aws_core.protocols import RestJsonClientProtocol +from smithy_core.auth import DefaultAuthResolver +from smithy_core.endpoints import BddEndpointResolver +from smithy_core.interceptors import Interceptor +from smithy_core.interfaces import ( + ClientProtocol, + EndpointResolver, + ProtocolConstructor, + ProtocolSettings, +) +from smithy_core.interfaces.auth import AuthScheme, AuthSchemeResolver +from smithy_core.shapes import ShapeID +from smithy_http.urllib3 import Urllib3HTTPClient + +from restjson_client._private.endpoints import BDD +from restjson_client._private.schemas import REST_JSON + +_PROTOCOL_SETTINGS = ProtocolSettings( + namespace="aws.protocoltests.restjson", + service_target="RestJson", + version="2019-12-16", + service_schema=REST_JSON, +) + + +class _RestJsonProtocolConfigOverrides(AwsConfigOverrides, total=False): + "Explicit field values RestJsonProtocolConfig.resolve accepts." + + endpoint_resolver: EndpointResolver | None + protocol: ( + ClientProtocol[Any, Any] | ProtocolConstructor[ClientProtocol[Any, Any]] | None + ) + auth_schemes: dict[ShapeID, AuthScheme[Any, Any, Any, Any]] | None + auth_scheme_resolver: AuthSchemeResolver | None + + +@dataclass(kw_only=True, repr=False, init=False) +class RestJsonProtocolConfig(AwsConfig): + "Configuration for RestJsonProtocolClient." + + interceptors: list[Interceptor[Any, Any, Any, Any]] = field( + default_factory=list[Interceptor[Any, Any, Any, Any]] + ) + "Hooks called during the execution of a request." + + endpoint_resolver: EndpointResolver | None = None + "Resolves the endpoint of each operation." + + protocol: ClientProtocol[Any, Any] | None = None + "Serializes requests and deserializes responses." + + auth_schemes: dict[ShapeID, AuthScheme[Any, Any, Any, Any]] | None = None + "Auth schemes by auth scheme ID." + + auth_scheme_resolver: AuthSchemeResolver | None = None + "Determines the auth scheme for each operation." + + _FIELDS: ClassVar[dict[str, FieldSpec]] = { + **AwsConfig._FIELDS, + "endpoint_uri": FieldSpec( + default=None, resolver=EndpointUriResolver("rest_json_protocol").program + ), + "endpoint_resolver": FieldSpec( + default_factory=lambda: BddEndpointResolver( + BDD, extensions=[AWS_RULES_EXTENSION] + ) + ), + "protocol": FieldSpec( + default_factory=lambda: RestJsonClientProtocol(_PROTOCOL_SETTINGS), + converter=lambda p: p(_PROTOCOL_SETTINGS) if isinstance(p, type) else p, + ), + "auth_schemes": FieldSpec( + default_factory=lambda: { + ShapeID("aws.auth#sigv4"): SigV4AuthScheme(service="restjson") + } + ), + "auth_scheme_resolver": FieldSpec(default_factory=DefaultAuthResolver), + "transport": FieldSpec(default_factory=lambda: Urllib3HTTPClient()), + } + + def set_auth_scheme(self, scheme: AuthScheme[Any, Any, Any, Any]) -> None: + "Set an auth scheme under its scheme ID." + auth_schemes = dict(self.auth_schemes or {}) + auth_schemes[scheme.scheme_id] = scheme + self.auth_schemes = auth_schemes + + @classmethod + def resolve( # pyright: ignore[reportIncompatibleMethodOverride] + cls, + *, + profile: str | None = None, + fs: FileSystem | None = None, + config_file_path: str | None = None, + credentials_file_path: str | None = None, + **overrides: Unpack[_RestJsonProtocolConfigOverrides], + ) -> Self: + "Resolve the config from overrides, the environment, and config files." + return cls._resolve( + profile=profile, + fs=fs, + config_file_path=config_file_path, + credentials_file_path=credentials_file_path, + overrides=overrides, + ) + + +type Plugin = Callable[[RestJsonProtocolConfig], None] +"A callable that customizes the client configuration." diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/models.py b/codegen-output-py/rest-json-1-client/src/restjson_client/models.py new file mode 100644 index 000000000..982b6a5b7 --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/models.py @@ -0,0 +1,967 @@ +from smithy_core._dynamic_models import ModelRegistry +from smithy_core.exceptions import ModeledError + +from ._private import schemas + + +class ServiceError(ModeledError): + """ + Base error for all errors in the service. + + Some exceptions do not extend from this class, including synthetic, + implicit, and shared exception types. + """ + + +_MODEL_INDEX = { + "AllQueryStringTypesInput": "ALL_QUERY_STRING_TYPES_INPUT", + "ClientOptionalDefaults": "CLIENT_OPTIONAL_DEFAULTS", + "ComplexError": "COMPLEX_ERROR", + "ComplexNestedErrorData": "COMPLEX_NESTED_ERROR_DATA", + "ConstantAndVariableQueryStringInput": "CONSTANT_AND_VARIABLE_QUERY_STRING_INPUT", + "ConstantQueryStringInput": "CONSTANT_QUERY_STRING_INPUT", + "ContentTypeParametersInput": "CONTENT_TYPE_PARAMETERS_INPUT", + "ContentTypeParametersOutput": "CONTENT_TYPE_PARAMETERS_OUTPUT", + "DatetimeOffsetsOutput": "DATETIME_OFFSETS_OUTPUT", + "Defaults": "DEFAULTS", + "Dialog": "DIALOG", + "EmptyInputAndEmptyOutputInput": "EMPTY_INPUT_AND_EMPTY_OUTPUT_INPUT", + "EmptyInputAndEmptyOutputOutput": "EMPTY_INPUT_AND_EMPTY_OUTPUT_OUTPUT", + "Farewell": "FAREWELL", + "FooError": "FOO_ERROR", + "FractionalSecondsOutput": "FRACTIONAL_SECONDS_OUTPUT", + "GreetingWithErrorsOutput": "GREETING_WITH_ERRORS_OUTPUT", + "HttpEmptyPrefixHeadersInput": "HTTP_EMPTY_PREFIX_HEADERS_INPUT", + "HttpEmptyPrefixHeadersOutput": "HTTP_EMPTY_PREFIX_HEADERS_OUTPUT", + "HttpPrefixHeadersInResponseInput": "HTTP_PREFIX_HEADERS_IN_RESPONSE_INPUT", + "HttpPrefixHeadersInResponseOutput": "HTTP_PREFIX_HEADERS_IN_RESPONSE_OUTPUT", + "HttpPrefixHeadersInput": "HTTP_PREFIX_HEADERS_INPUT", + "HttpPrefixHeadersOutput": "HTTP_PREFIX_HEADERS_OUTPUT", + "HttpRequestWithFloatLabelsInput": "HTTP_REQUEST_WITH_FLOAT_LABELS_INPUT", + "HttpRequestWithGreedyLabelInPathInput": "HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_INPUT", + "HttpRequestWithLabelsAndTimestampFormatInput": "HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_INPUT", + "HttpRequestWithLabelsInput": "HTTP_REQUEST_WITH_LABELS_INPUT", + "HttpRequestWithRegexLiteralInput": "HTTP_REQUEST_WITH_REGEX_LITERAL_INPUT", + "HttpResponseCodeOutput": "HTTP_RESPONSE_CODE_OUTPUT", + "IgnoreQueryParamsInResponseOutput": "IGNORE_QUERY_PARAMS_IN_RESPONSE_OUTPUT", + "InvalidGreeting": "INVALID_GREETING", + "MalformedAcceptWithGenericStringOutput": "MALFORMED_ACCEPT_WITH_GENERIC_STRING_OUTPUT", + "MalformedAcceptWithPayloadOutput": "MALFORMED_ACCEPT_WITH_PAYLOAD_OUTPUT", + "MalformedBlobInput": "MALFORMED_BLOB_INPUT", + "MalformedBooleanInput": "MALFORMED_BOOLEAN_INPUT", + "MalformedByteInput": "MALFORMED_BYTE_INPUT", + "MalformedContentTypeWithGenericStringInput": "MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_INPUT", + "MalformedContentTypeWithPayloadInput": "MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_INPUT", + "MalformedContentTypeWithoutBodyEmptyInputInput": "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_INPUT", + "MalformedDoubleInput": "MALFORMED_DOUBLE_INPUT", + "MalformedFloatInput": "MALFORMED_FLOAT_INPUT", + "MalformedIntegerInput": "MALFORMED_INTEGER_INPUT", + "MalformedListInput": "MALFORMED_LIST_INPUT", + "MalformedLongInput": "MALFORMED_LONG_INPUT", + "MalformedMapInput": "MALFORMED_MAP_INPUT", + "MalformedRequestBodyInput": "MALFORMED_REQUEST_BODY_INPUT", + "MalformedShortInput": "MALFORMED_SHORT_INPUT", + "MalformedStringInput": "MALFORMED_STRING_INPUT", + "MalformedTimestampBodyDateTimeInput": "MALFORMED_TIMESTAMP_BODY_DATE_TIME_INPUT", + "MalformedTimestampBodyDefaultInput": "MALFORMED_TIMESTAMP_BODY_DEFAULT_INPUT", + "MalformedTimestampBodyHttpDateInput": "MALFORMED_TIMESTAMP_BODY_HTTP_DATE_INPUT", + "MalformedTimestampHeaderDateTimeInput": "MALFORMED_TIMESTAMP_HEADER_DATE_TIME_INPUT", + "MalformedTimestampHeaderDefaultInput": "MALFORMED_TIMESTAMP_HEADER_DEFAULT_INPUT", + "MalformedTimestampHeaderEpochInput": "MALFORMED_TIMESTAMP_HEADER_EPOCH_INPUT", + "MalformedTimestampPathDefaultInput": "MALFORMED_TIMESTAMP_PATH_DEFAULT_INPUT", + "MalformedTimestampPathEpochInput": "MALFORMED_TIMESTAMP_PATH_EPOCH_INPUT", + "MalformedTimestampPathHttpDateInput": "MALFORMED_TIMESTAMP_PATH_HTTP_DATE_INPUT", + "MalformedTimestampQueryDefaultInput": "MALFORMED_TIMESTAMP_QUERY_DEFAULT_INPUT", + "MalformedTimestampQueryEpochInput": "MALFORMED_TIMESTAMP_QUERY_EPOCH_INPUT", + "MalformedTimestampQueryHttpDateInput": "MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_INPUT", + "MalformedUnionInput": "MALFORMED_UNION_INPUT", + "MediaTypeHeaderInput": "MEDIA_TYPE_HEADER_INPUT", + "MediaTypeHeaderOutput": "MEDIA_TYPE_HEADER_OUTPUT", + "MyUnion": "MY_UNION", + "MyUnionStringValue": "MY_UNION", + "MyUnionBooleanValue": "MY_UNION", + "MyUnionNumberValue": "MY_UNION", + "MyUnionBlobValue": "MY_UNION", + "MyUnionTimestampValue": "MY_UNION", + "MyUnionEnumValue": "MY_UNION", + "MyUnionListValue": "MY_UNION", + "MyUnionMapValue": "MY_UNION", + "MyUnionStructureValue": "MY_UNION", + "MyUnionRenamedStructureValue": "MY_UNION", + "MyUnionUnionValue": "MY_UNION", + "MyUnionUnknown": "MY_UNION", + "NestedPayload": "NESTED_PAYLOAD", + "NestedUnion": "NESTED_UNION", + "NestedUnionStringValue": "NESTED_UNION", + "NestedUnionUnknown": "NESTED_UNION", + "NoInputAndOutputOutput": "NO_INPUT_AND_OUTPUT_OUTPUT", + "OmitsNullSerializesEmptyStringInput": "OMITS_NULL_SERIALIZES_EMPTY_STRING_INPUT", + "OmitsSerializingEmptyListsInput": "OMITS_SERIALIZING_EMPTY_LISTS_INPUT", + "OperationWithDefaultsInput": "OPERATION_WITH_DEFAULTS_INPUT", + "OperationWithDefaultsOutput": "OPERATION_WITH_DEFAULTS_OUTPUT", + "OperationWithNestedStructureInput": "OPERATION_WITH_NESTED_STRUCTURE_INPUT", + "OperationWithNestedStructureOutput": "OPERATION_WITH_NESTED_STRUCTURE_OUTPUT", + "PayloadConfig": "PAYLOAD_CONFIG", + "PlayerAction": "PLAYER_ACTION", + "PlayerActionQuit": "PLAYER_ACTION", + "PlayerActionUnknown": "PLAYER_ACTION", + "PostPlayerActionInput": "POST_PLAYER_ACTION_INPUT", + "PostPlayerActionOutput": "POST_PLAYER_ACTION_OUTPUT", + "PostUnionWithJsonNameInput": "POST_UNION_WITH_JSON_NAME_INPUT", + "PostUnionWithJsonNameOutput": "POST_UNION_WITH_JSON_NAME_OUTPUT", + "PutWithContentEncodingInput": "PUT_WITH_CONTENT_ENCODING_INPUT", + "QueryIdempotencyTokenAutoFillInput": "QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_INPUT", + "QueryParamsAsStringListMapInput": "QUERY_PARAMS_AS_STRING_LIST_MAP_INPUT", + "QueryPrecedenceInput": "QUERY_PRECEDENCE_INPUT", + "RecursiveShapesInputOutputNested1": "RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED1", + "RecursiveShapesInputOutputNested2": "RECURSIVE_SHAPES_INPUT_OUTPUT_NESTED2", + "ResponseCodeRequiredOutput": "RESPONSE_CODE_REQUIRED_OUTPUT", + "SimpleUnion": "SIMPLE_UNION", + "SimpleUnionInt": "SIMPLE_UNION", + "SimpleUnionString": "SIMPLE_UNION", + "SimpleUnionUnknown": "SIMPLE_UNION", + "StringEnum": "STRING_ENUM", + "StructureListMember": "STRUCTURE_LIST_MEMBER", + "TestConfig": "TEST_CONFIG", + "TestEnum": "TEST_ENUM", + "TestIntEnum": "TEST_INT_ENUM", + "TopLevel": "TOP_LEVEL", + "UnionPayload": "UNION_PAYLOAD", + "UnionPayloadGreeting": "UNION_PAYLOAD", + "UnionPayloadUnknown": "UNION_PAYLOAD", + "UnionWithJsonName": "UNION_WITH_JSON_NAME", + "UnionWithJsonNameFoo": "UNION_WITH_JSON_NAME", + "UnionWithJsonNameBar": "UNION_WITH_JSON_NAME", + "UnionWithJsonNameBaz": "UNION_WITH_JSON_NAME", + "UnionWithJsonNameUnknown": "UNION_WITH_JSON_NAME", + "RenamedGreeting": "RENAMED_GREETING", + "FooEnum": "FOO_ENUM", + "GreetingStruct": "GREETING_STRUCT", + "IntegerEnum": "INTEGER_ENUM", + "AllQueryStringTypesOutput": "ALL_QUERY_STRING_TYPES_OUTPUT", + "ConstantAndVariableQueryStringOutput": "CONSTANT_AND_VARIABLE_QUERY_STRING_OUTPUT", + "ConstantQueryStringOutput": "CONSTANT_QUERY_STRING_OUTPUT", + "DatetimeOffsetsInput": "DATETIME_OFFSETS_INPUT", + "DocumentTypeInput": "DOCUMENT_TYPE_INPUT", + "DocumentTypeOutput": "DOCUMENT_TYPE_OUTPUT", + "DocumentTypeAsMapValueInput": "DOCUMENT_TYPE_AS_MAP_VALUE_INPUT", + "DocumentTypeAsMapValueOutput": "DOCUMENT_TYPE_AS_MAP_VALUE_OUTPUT", + "DocumentTypeAsPayloadInput": "DOCUMENT_TYPE_AS_PAYLOAD_INPUT", + "DocumentTypeAsPayloadOutput": "DOCUMENT_TYPE_AS_PAYLOAD_OUTPUT", + "EndpointOperationInput": "ENDPOINT_OPERATION_INPUT", + "EndpointOperationOutput": "ENDPOINT_OPERATION_OUTPUT", + "EndpointWithHostLabelOperationInput": "ENDPOINT_WITH_HOST_LABEL_OPERATION_INPUT", + "EndpointWithHostLabelOperationOutput": "ENDPOINT_WITH_HOST_LABEL_OPERATION_OUTPUT", + "FractionalSecondsInput": "FRACTIONAL_SECONDS_INPUT", + "GreetingWithErrorsInput": "GREETING_WITH_ERRORS_INPUT", + "HostWithPathOperationInput": "HOST_WITH_PATH_OPERATION_INPUT", + "HostWithPathOperationOutput": "HOST_WITH_PATH_OPERATION_OUTPUT", + "HttpChecksumRequiredInput": "HTTP_CHECKSUM_REQUIRED_INPUT", + "HttpChecksumRequiredOutput": "HTTP_CHECKSUM_REQUIRED_OUTPUT", + "HttpEnumPayloadInput": "HTTP_ENUM_PAYLOAD_INPUT", + "HttpEnumPayloadOutput": "HTTP_ENUM_PAYLOAD_OUTPUT", + "HttpPayloadTraitsInput": "HTTP_PAYLOAD_TRAITS_INPUT", + "HttpPayloadTraitsOutput": "HTTP_PAYLOAD_TRAITS_OUTPUT", + "HttpPayloadTraitsWithMediaTypeInput": "HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_INPUT", + "HttpPayloadTraitsWithMediaTypeOutput": "HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE_OUTPUT", + "HttpPayloadWithStructureInput": "HTTP_PAYLOAD_WITH_STRUCTURE_INPUT", + "HttpPayloadWithStructureOutput": "HTTP_PAYLOAD_WITH_STRUCTURE_OUTPUT", + "HttpPayloadWithUnionInput": "HTTP_PAYLOAD_WITH_UNION_INPUT", + "HttpPayloadWithUnionOutput": "HTTP_PAYLOAD_WITH_UNION_OUTPUT", + "HttpQueryParamsOnlyOperationInput": "HTTP_QUERY_PARAMS_ONLY_OPERATION_INPUT", + "HttpQueryParamsOnlyOperationOutput": "HTTP_QUERY_PARAMS_ONLY_OPERATION_OUTPUT", + "HttpRequestWithFloatLabelsOutput": "HTTP_REQUEST_WITH_FLOAT_LABELS_OUTPUT", + "HttpRequestWithGreedyLabelInPathOutput": "HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH_OUTPUT", + "HttpRequestWithLabelsOutput": "HTTP_REQUEST_WITH_LABELS_OUTPUT", + "HttpRequestWithLabelsAndTimestampFormatOutput": "HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT_OUTPUT", + "HttpRequestWithRegexLiteralOutput": "HTTP_REQUEST_WITH_REGEX_LITERAL_OUTPUT", + "HttpResponseCodeInput": "HTTP_RESPONSE_CODE_INPUT", + "HttpStringPayloadInput": "HTTP_STRING_PAYLOAD_INPUT", + "HttpStringPayloadOutput": "HTTP_STRING_PAYLOAD_OUTPUT", + "IgnoreQueryParamsInResponseInput": "IGNORE_QUERY_PARAMS_IN_RESPONSE_INPUT", + "InputAndOutputWithHeadersInput": "INPUT_AND_OUTPUT_WITH_HEADERS_INPUT", + "InputAndOutputWithHeadersOutput": "INPUT_AND_OUTPUT_WITH_HEADERS_OUTPUT", + "JsonBlobsInput": "JSON_BLOBS_INPUT", + "JsonBlobsOutput": "JSON_BLOBS_OUTPUT", + "JsonEnumsInput": "JSON_ENUMS_INPUT", + "JsonEnumsOutput": "JSON_ENUMS_OUTPUT", + "JsonIntEnumsInput": "JSON_INT_ENUMS_INPUT", + "JsonIntEnumsOutput": "JSON_INT_ENUMS_OUTPUT", + "JsonListsInput": "JSON_LISTS_INPUT", + "JsonListsOutput": "JSON_LISTS_OUTPUT", + "JsonMapsInput": "JSON_MAPS_INPUT", + "JsonMapsOutput": "JSON_MAPS_OUTPUT", + "JsonTimestampsInput": "JSON_TIMESTAMPS_INPUT", + "JsonTimestampsOutput": "JSON_TIMESTAMPS_OUTPUT", + "JsonUnionsInput": "JSON_UNIONS_INPUT", + "JsonUnionsOutput": "JSON_UNIONS_OUTPUT", + "MalformedAcceptWithBodyInput": "MALFORMED_ACCEPT_WITH_BODY_INPUT", + "MalformedAcceptWithBodyOutput": "MALFORMED_ACCEPT_WITH_BODY_OUTPUT", + "MalformedAcceptWithGenericStringInput": "MALFORMED_ACCEPT_WITH_GENERIC_STRING_INPUT", + "MalformedAcceptWithPayloadInput": "MALFORMED_ACCEPT_WITH_PAYLOAD_INPUT", + "MalformedBlobOutput": "MALFORMED_BLOB_OUTPUT", + "MalformedBooleanOutput": "MALFORMED_BOOLEAN_OUTPUT", + "MalformedByteOutput": "MALFORMED_BYTE_OUTPUT", + "MalformedContentTypeWithBodyInput": "MALFORMED_CONTENT_TYPE_WITH_BODY_INPUT", + "MalformedContentTypeWithBodyOutput": "MALFORMED_CONTENT_TYPE_WITH_BODY_OUTPUT", + "MalformedContentTypeWithGenericStringOutput": "MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING_OUTPUT", + "MalformedContentTypeWithPayloadOutput": "MALFORMED_CONTENT_TYPE_WITH_PAYLOAD_OUTPUT", + "MalformedContentTypeWithoutBodyInput": "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_INPUT", + "MalformedContentTypeWithoutBodyOutput": "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_OUTPUT", + "MalformedContentTypeWithoutBodyEmptyInputOutput": "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT_OUTPUT", + "MalformedDoubleOutput": "MALFORMED_DOUBLE_OUTPUT", + "MalformedFloatOutput": "MALFORMED_FLOAT_OUTPUT", + "MalformedIntegerOutput": "MALFORMED_INTEGER_OUTPUT", + "MalformedListOutput": "MALFORMED_LIST_OUTPUT", + "MalformedLongOutput": "MALFORMED_LONG_OUTPUT", + "MalformedMapOutput": "MALFORMED_MAP_OUTPUT", + "MalformedRequestBodyOutput": "MALFORMED_REQUEST_BODY_OUTPUT", + "MalformedShortOutput": "MALFORMED_SHORT_OUTPUT", + "MalformedStringOutput": "MALFORMED_STRING_OUTPUT", + "MalformedTimestampBodyDateTimeOutput": "MALFORMED_TIMESTAMP_BODY_DATE_TIME_OUTPUT", + "MalformedTimestampBodyDefaultOutput": "MALFORMED_TIMESTAMP_BODY_DEFAULT_OUTPUT", + "MalformedTimestampBodyHttpDateOutput": "MALFORMED_TIMESTAMP_BODY_HTTP_DATE_OUTPUT", + "MalformedTimestampHeaderDateTimeOutput": "MALFORMED_TIMESTAMP_HEADER_DATE_TIME_OUTPUT", + "MalformedTimestampHeaderDefaultOutput": "MALFORMED_TIMESTAMP_HEADER_DEFAULT_OUTPUT", + "MalformedTimestampHeaderEpochOutput": "MALFORMED_TIMESTAMP_HEADER_EPOCH_OUTPUT", + "MalformedTimestampPathDefaultOutput": "MALFORMED_TIMESTAMP_PATH_DEFAULT_OUTPUT", + "MalformedTimestampPathEpochOutput": "MALFORMED_TIMESTAMP_PATH_EPOCH_OUTPUT", + "MalformedTimestampPathHttpDateOutput": "MALFORMED_TIMESTAMP_PATH_HTTP_DATE_OUTPUT", + "MalformedTimestampQueryDefaultOutput": "MALFORMED_TIMESTAMP_QUERY_DEFAULT_OUTPUT", + "MalformedTimestampQueryEpochOutput": "MALFORMED_TIMESTAMP_QUERY_EPOCH_OUTPUT", + "MalformedTimestampQueryHttpDateOutput": "MALFORMED_TIMESTAMP_QUERY_HTTP_DATE_OUTPUT", + "MalformedUnionOutput": "MALFORMED_UNION_OUTPUT", + "NoInputAndNoOutputInput": "NO_INPUT_AND_NO_OUTPUT_INPUT", + "NoInputAndNoOutputOutput": "NO_INPUT_AND_NO_OUTPUT_OUTPUT", + "NoInputAndOutputInput": "NO_INPUT_AND_OUTPUT_INPUT", + "NullAndEmptyHeadersClientInput": "NULL_AND_EMPTY_HEADERS_CLIENT_INPUT", + "NullAndEmptyHeadersClientOutput": "NULL_AND_EMPTY_HEADERS_CLIENT_OUTPUT", + "NullAndEmptyHeadersServerInput": "NULL_AND_EMPTY_HEADERS_SERVER_INPUT", + "NullAndEmptyHeadersServerOutput": "NULL_AND_EMPTY_HEADERS_SERVER_OUTPUT", + "OmitsNullSerializesEmptyStringOutput": "OMITS_NULL_SERIALIZES_EMPTY_STRING_OUTPUT", + "OmitsSerializingEmptyListsOutput": "OMITS_SERIALIZING_EMPTY_LISTS_OUTPUT", + "PutWithContentEncodingOutput": "PUT_WITH_CONTENT_ENCODING_OUTPUT", + "QueryIdempotencyTokenAutoFillOutput": "QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL_OUTPUT", + "QueryParamsAsStringListMapOutput": "QUERY_PARAMS_AS_STRING_LIST_MAP_OUTPUT", + "QueryPrecedenceOutput": "QUERY_PRECEDENCE_OUTPUT", + "RecursiveShapesInput": "RECURSIVE_SHAPES_INPUT", + "RecursiveShapesOutput": "RECURSIVE_SHAPES_OUTPUT", + "ResponseCodeHttpFallbackInput": "RESPONSE_CODE_HTTP_FALLBACK_INPUT", + "ResponseCodeHttpFallbackOutput": "RESPONSE_CODE_HTTP_FALLBACK_OUTPUT", + "ResponseCodeRequiredInput": "RESPONSE_CODE_REQUIRED_INPUT", + "SimpleScalarPropertiesInput": "SIMPLE_SCALAR_PROPERTIES_INPUT", + "SimpleScalarPropertiesOutput": "SIMPLE_SCALAR_PROPERTIES_OUTPUT", + "SparseJsonListsInput": "SPARSE_JSON_LISTS_INPUT", + "SparseJsonListsOutput": "SPARSE_JSON_LISTS_OUTPUT", + "SparseJsonMapsInput": "SPARSE_JSON_MAPS_INPUT", + "SparseJsonMapsOutput": "SPARSE_JSON_MAPS_OUTPUT", + "TestBodyStructureInput": "TEST_BODY_STRUCTURE_INPUT", + "TestBodyStructureOutput": "TEST_BODY_STRUCTURE_OUTPUT", + "TestGetNoInputNoPayloadInput": "TEST_GET_NO_INPUT_NO_PAYLOAD_INPUT", + "TestGetNoInputNoPayloadOutput": "TEST_GET_NO_INPUT_NO_PAYLOAD_OUTPUT", + "TestGetNoPayloadInput": "TEST_GET_NO_PAYLOAD_INPUT", + "TestGetNoPayloadOutput": "TEST_GET_NO_PAYLOAD_OUTPUT", + "TestPayloadBlobInput": "TEST_PAYLOAD_BLOB_INPUT", + "TestPayloadBlobOutput": "TEST_PAYLOAD_BLOB_OUTPUT", + "TestPayloadStructureInput": "TEST_PAYLOAD_STRUCTURE_INPUT", + "TestPayloadStructureOutput": "TEST_PAYLOAD_STRUCTURE_OUTPUT", + "TestPostNoInputNoPayloadInput": "TEST_POST_NO_INPUT_NO_PAYLOAD_INPUT", + "TestPostNoInputNoPayloadOutput": "TEST_POST_NO_INPUT_NO_PAYLOAD_OUTPUT", + "TestPostNoPayloadInput": "TEST_POST_NO_PAYLOAD_INPUT", + "TestPostNoPayloadOutput": "TEST_POST_NO_PAYLOAD_OUTPUT", + "TimestampFormatHeadersInput": "TIMESTAMP_FORMAT_HEADERS_INPUT", + "TimestampFormatHeadersOutput": "TIMESTAMP_FORMAT_HEADERS_OUTPUT", + "UnitInputAndOutputInput": "UNIT_INPUT_AND_OUTPUT_INPUT", + "UnitInputAndOutputOutput": "UNIT_INPUT_AND_OUTPUT_OUTPUT", +} + +_RENAMES = { + "RenamedGreeting": "RENAMED_GREETING", +} + +_TARGET_NAMES = { + "aws.protocoltests.restjson.nested#GreetingStruct": "RenamedGreeting", +} + +_OPERATIONS: dict[str, tuple[tuple[str, ...], tuple[str, ...]]] = { + "ALL_QUERY_STRING_TYPES": ( + (), + ("aws.auth#sigv4",), + ), + "CONSTANT_AND_VARIABLE_QUERY_STRING": ( + (), + ("aws.auth#sigv4",), + ), + "CONSTANT_QUERY_STRING": ( + (), + ("aws.auth#sigv4",), + ), + "CONTENT_TYPE_PARAMETERS": ( + (), + ("aws.auth#sigv4",), + ), + "DATETIME_OFFSETS": ( + (), + ("aws.auth#sigv4",), + ), + "DOCUMENT_TYPE": ( + (), + ("aws.auth#sigv4",), + ), + "DOCUMENT_TYPE_AS_MAP_VALUE": ( + (), + ("aws.auth#sigv4",), + ), + "DOCUMENT_TYPE_AS_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "EMPTY_INPUT_AND_EMPTY_OUTPUT": ( + (), + ("aws.auth#sigv4",), + ), + "ENDPOINT_OPERATION": ( + (), + ("aws.auth#sigv4",), + ), + "ENDPOINT_WITH_HOST_LABEL_OPERATION": ( + (), + ("aws.auth#sigv4",), + ), + "FRACTIONAL_SECONDS": ( + (), + ("aws.auth#sigv4",), + ), + "GREETING_WITH_ERRORS": ( + ( + "aws.protocoltests.restjson#ComplexError", + "aws.protocoltests.restjson#FooError", + "aws.protocoltests.restjson#InvalidGreeting", + ), + ("aws.auth#sigv4",), + ), + "HOST_WITH_PATH_OPERATION": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_CHECKSUM_REQUIRED": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_EMPTY_PREFIX_HEADERS": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_ENUM_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_PAYLOAD_TRAITS": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_PAYLOAD_WITH_STRUCTURE": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_PAYLOAD_WITH_UNION": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_PREFIX_HEADERS": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_PREFIX_HEADERS_IN_RESPONSE": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_QUERY_PARAMS_ONLY_OPERATION": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_REQUEST_WITH_FLOAT_LABELS": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_REQUEST_WITH_LABELS": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_REQUEST_WITH_REGEX_LITERAL": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_RESPONSE_CODE": ( + (), + ("aws.auth#sigv4",), + ), + "HTTP_STRING_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "IGNORE_QUERY_PARAMS_IN_RESPONSE": ( + (), + ("aws.auth#sigv4",), + ), + "INPUT_AND_OUTPUT_WITH_HEADERS": ( + (), + ("aws.auth#sigv4",), + ), + "JSON_BLOBS": ( + (), + ("aws.auth#sigv4",), + ), + "JSON_ENUMS": ( + (), + ("aws.auth#sigv4",), + ), + "JSON_INT_ENUMS": ( + (), + ("aws.auth#sigv4",), + ), + "JSON_LISTS": ( + (), + ("aws.auth#sigv4",), + ), + "JSON_MAPS": ( + (), + ("aws.auth#sigv4",), + ), + "JSON_TIMESTAMPS": ( + (), + ("aws.auth#sigv4",), + ), + "JSON_UNIONS": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_ACCEPT_WITH_BODY": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_ACCEPT_WITH_GENERIC_STRING": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_ACCEPT_WITH_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_BLOB": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_BOOLEAN": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_BYTE": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_CONTENT_TYPE_WITH_BODY": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_CONTENT_TYPE_WITH_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_DOUBLE": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_FLOAT": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_INTEGER": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_LIST": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_LONG": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_MAP": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_REQUEST_BODY": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_SHORT": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_STRING": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_BODY_DATE_TIME": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_BODY_DEFAULT": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_BODY_HTTP_DATE": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_HEADER_DATE_TIME": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_HEADER_DEFAULT": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_HEADER_EPOCH": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_PATH_DEFAULT": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_PATH_EPOCH": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_PATH_HTTP_DATE": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_QUERY_DEFAULT": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_QUERY_EPOCH": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_TIMESTAMP_QUERY_HTTP_DATE": ( + (), + ("aws.auth#sigv4",), + ), + "MALFORMED_UNION": ( + (), + ("aws.auth#sigv4",), + ), + "MEDIA_TYPE_HEADER": ( + (), + ("aws.auth#sigv4",), + ), + "NO_INPUT_AND_NO_OUTPUT": ( + (), + ("aws.auth#sigv4",), + ), + "NO_INPUT_AND_OUTPUT": ( + (), + ("aws.auth#sigv4",), + ), + "NULL_AND_EMPTY_HEADERS_CLIENT": ( + (), + ("aws.auth#sigv4",), + ), + "NULL_AND_EMPTY_HEADERS_SERVER": ( + (), + ("aws.auth#sigv4",), + ), + "OMITS_NULL_SERIALIZES_EMPTY_STRING": ( + (), + ("aws.auth#sigv4",), + ), + "OMITS_SERIALIZING_EMPTY_LISTS": ( + (), + ("aws.auth#sigv4",), + ), + "OPERATION_WITH_DEFAULTS": ( + (), + ("aws.auth#sigv4",), + ), + "OPERATION_WITH_NESTED_STRUCTURE": ( + (), + ("aws.auth#sigv4",), + ), + "POST_PLAYER_ACTION": ( + (), + ("aws.auth#sigv4",), + ), + "POST_UNION_WITH_JSON_NAME": ( + (), + ("aws.auth#sigv4",), + ), + "PUT_WITH_CONTENT_ENCODING": ( + (), + ("aws.auth#sigv4",), + ), + "QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL": ( + (), + ("aws.auth#sigv4",), + ), + "QUERY_PARAMS_AS_STRING_LIST_MAP": ( + (), + ("aws.auth#sigv4",), + ), + "QUERY_PRECEDENCE": ( + (), + ("aws.auth#sigv4",), + ), + "RECURSIVE_SHAPES": ( + (), + ("aws.auth#sigv4",), + ), + "RESPONSE_CODE_HTTP_FALLBACK": ( + (), + ("aws.auth#sigv4",), + ), + "RESPONSE_CODE_REQUIRED": ( + (), + ("aws.auth#sigv4",), + ), + "SIMPLE_SCALAR_PROPERTIES": ( + (), + ("aws.auth#sigv4",), + ), + "SPARSE_JSON_LISTS": ( + (), + ("aws.auth#sigv4",), + ), + "SPARSE_JSON_MAPS": ( + (), + ("aws.auth#sigv4",), + ), + "TEST_BODY_STRUCTURE": ( + (), + ("aws.auth#sigv4",), + ), + "TEST_GET_NO_INPUT_NO_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "TEST_GET_NO_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "TEST_PAYLOAD_BLOB": ( + (), + ("aws.auth#sigv4",), + ), + "TEST_PAYLOAD_STRUCTURE": ( + (), + ("aws.auth#sigv4",), + ), + "TEST_POST_NO_INPUT_NO_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "TEST_POST_NO_PAYLOAD": ( + (), + ("aws.auth#sigv4",), + ), + "TIMESTAMP_FORMAT_HEADERS": ( + (), + ("aws.auth#sigv4",), + ), + "UNIT_INPUT_AND_OUTPUT": ( + (), + ("aws.auth#sigv4",), + ), +} + +_MODEL_NAMES = (*tuple(_MODEL_INDEX), "Unit") +__all__ = ("ServiceError", *_MODEL_NAMES, *_OPERATIONS) # pyright: ignore[reportUnsupportedDunderAll] + + +_registry = ModelRegistry( + schemas, + renames=_RENAMES, + index=_MODEL_INDEX, + target_names=_TARGET_NAMES, + shape_names=frozenset( + { + "AllQueryStringTypesInput", + "AllQueryStringTypesOutput", + "ClientOptionalDefaults", + "ComplexError", + "ComplexNestedErrorData", + "ConstantAndVariableQueryStringInput", + "ConstantAndVariableQueryStringOutput", + "ConstantQueryStringInput", + "ConstantQueryStringOutput", + "ContentTypeParametersInput", + "ContentTypeParametersOutput", + "DatetimeOffsetsInput", + "DatetimeOffsetsOutput", + "Defaults", + "Dialog", + "DocumentTypeAsMapValueInput", + "DocumentTypeAsMapValueOutput", + "DocumentTypeAsPayloadInput", + "DocumentTypeAsPayloadOutput", + "DocumentTypeInput", + "DocumentTypeOutput", + "EmptyInputAndEmptyOutputInput", + "EmptyInputAndEmptyOutputOutput", + "EndpointOperationInput", + "EndpointOperationOutput", + "EndpointWithHostLabelOperationInput", + "EndpointWithHostLabelOperationOutput", + "Farewell", + "FooEnum", + "FooError", + "FractionalSecondsInput", + "FractionalSecondsOutput", + "GreetingStruct", + "GreetingWithErrorsInput", + "GreetingWithErrorsOutput", + "HostWithPathOperationInput", + "HostWithPathOperationOutput", + "HttpChecksumRequiredInput", + "HttpChecksumRequiredOutput", + "HttpEmptyPrefixHeadersInput", + "HttpEmptyPrefixHeadersOutput", + "HttpEnumPayloadInput", + "HttpEnumPayloadOutput", + "HttpPayloadTraitsInput", + "HttpPayloadTraitsOutput", + "HttpPayloadTraitsWithMediaTypeInput", + "HttpPayloadTraitsWithMediaTypeOutput", + "HttpPayloadWithStructureInput", + "HttpPayloadWithStructureOutput", + "HttpPayloadWithUnionInput", + "HttpPayloadWithUnionOutput", + "HttpPrefixHeadersInResponseInput", + "HttpPrefixHeadersInResponseOutput", + "HttpPrefixHeadersInput", + "HttpPrefixHeadersOutput", + "HttpQueryParamsOnlyOperationInput", + "HttpQueryParamsOnlyOperationOutput", + "HttpRequestWithFloatLabelsInput", + "HttpRequestWithFloatLabelsOutput", + "HttpRequestWithGreedyLabelInPathInput", + "HttpRequestWithGreedyLabelInPathOutput", + "HttpRequestWithLabelsAndTimestampFormatInput", + "HttpRequestWithLabelsAndTimestampFormatOutput", + "HttpRequestWithLabelsInput", + "HttpRequestWithLabelsOutput", + "HttpRequestWithRegexLiteralInput", + "HttpRequestWithRegexLiteralOutput", + "HttpResponseCodeInput", + "HttpResponseCodeOutput", + "HttpStringPayloadInput", + "HttpStringPayloadOutput", + "IgnoreQueryParamsInResponseInput", + "IgnoreQueryParamsInResponseOutput", + "InputAndOutputWithHeadersInput", + "InputAndOutputWithHeadersOutput", + "IntegerEnum", + "InvalidGreeting", + "JsonBlobsInput", + "JsonBlobsOutput", + "JsonEnumsInput", + "JsonEnumsOutput", + "JsonIntEnumsInput", + "JsonIntEnumsOutput", + "JsonListsInput", + "JsonListsOutput", + "JsonMapsInput", + "JsonMapsOutput", + "JsonTimestampsInput", + "JsonTimestampsOutput", + "JsonUnionsInput", + "JsonUnionsOutput", + "MalformedAcceptWithBodyInput", + "MalformedAcceptWithBodyOutput", + "MalformedAcceptWithGenericStringInput", + "MalformedAcceptWithGenericStringOutput", + "MalformedAcceptWithPayloadInput", + "MalformedAcceptWithPayloadOutput", + "MalformedBlobInput", + "MalformedBlobOutput", + "MalformedBooleanInput", + "MalformedBooleanOutput", + "MalformedByteInput", + "MalformedByteOutput", + "MalformedContentTypeWithBodyInput", + "MalformedContentTypeWithBodyOutput", + "MalformedContentTypeWithGenericStringInput", + "MalformedContentTypeWithGenericStringOutput", + "MalformedContentTypeWithPayloadInput", + "MalformedContentTypeWithPayloadOutput", + "MalformedContentTypeWithoutBodyEmptyInputInput", + "MalformedContentTypeWithoutBodyEmptyInputOutput", + "MalformedContentTypeWithoutBodyInput", + "MalformedContentTypeWithoutBodyOutput", + "MalformedDoubleInput", + "MalformedDoubleOutput", + "MalformedFloatInput", + "MalformedFloatOutput", + "MalformedIntegerInput", + "MalformedIntegerOutput", + "MalformedListInput", + "MalformedListOutput", + "MalformedLongInput", + "MalformedLongOutput", + "MalformedMapInput", + "MalformedMapOutput", + "MalformedRequestBodyInput", + "MalformedRequestBodyOutput", + "MalformedShortInput", + "MalformedShortOutput", + "MalformedStringInput", + "MalformedStringOutput", + "MalformedTimestampBodyDateTimeInput", + "MalformedTimestampBodyDateTimeOutput", + "MalformedTimestampBodyDefaultInput", + "MalformedTimestampBodyDefaultOutput", + "MalformedTimestampBodyHttpDateInput", + "MalformedTimestampBodyHttpDateOutput", + "MalformedTimestampHeaderDateTimeInput", + "MalformedTimestampHeaderDateTimeOutput", + "MalformedTimestampHeaderDefaultInput", + "MalformedTimestampHeaderDefaultOutput", + "MalformedTimestampHeaderEpochInput", + "MalformedTimestampHeaderEpochOutput", + "MalformedTimestampPathDefaultInput", + "MalformedTimestampPathDefaultOutput", + "MalformedTimestampPathEpochInput", + "MalformedTimestampPathEpochOutput", + "MalformedTimestampPathHttpDateInput", + "MalformedTimestampPathHttpDateOutput", + "MalformedTimestampQueryDefaultInput", + "MalformedTimestampQueryDefaultOutput", + "MalformedTimestampQueryEpochInput", + "MalformedTimestampQueryEpochOutput", + "MalformedTimestampQueryHttpDateInput", + "MalformedTimestampQueryHttpDateOutput", + "MalformedUnionInput", + "MalformedUnionOutput", + "MediaTypeHeaderInput", + "MediaTypeHeaderOutput", + "MyUnion", + "NestedPayload", + "NestedUnion", + "NoInputAndNoOutputInput", + "NoInputAndNoOutputOutput", + "NoInputAndOutputInput", + "NoInputAndOutputOutput", + "NullAndEmptyHeadersClientInput", + "NullAndEmptyHeadersClientOutput", + "NullAndEmptyHeadersServerInput", + "NullAndEmptyHeadersServerOutput", + "OmitsNullSerializesEmptyStringInput", + "OmitsNullSerializesEmptyStringOutput", + "OmitsSerializingEmptyListsInput", + "OmitsSerializingEmptyListsOutput", + "OperationWithDefaultsInput", + "OperationWithDefaultsOutput", + "OperationWithNestedStructureInput", + "OperationWithNestedStructureOutput", + "PayloadConfig", + "PlayerAction", + "PostPlayerActionInput", + "PostPlayerActionOutput", + "PostUnionWithJsonNameInput", + "PostUnionWithJsonNameOutput", + "PutWithContentEncodingInput", + "PutWithContentEncodingOutput", + "QueryIdempotencyTokenAutoFillInput", + "QueryIdempotencyTokenAutoFillOutput", + "QueryParamsAsStringListMapInput", + "QueryParamsAsStringListMapOutput", + "QueryPrecedenceInput", + "QueryPrecedenceOutput", + "RecursiveShapesInput", + "RecursiveShapesInputOutputNested1", + "RecursiveShapesInputOutputNested2", + "RecursiveShapesOutput", + "RenamedGreeting", + "ResponseCodeHttpFallbackInput", + "ResponseCodeHttpFallbackOutput", + "ResponseCodeRequiredInput", + "ResponseCodeRequiredOutput", + "SimpleScalarPropertiesInput", + "SimpleScalarPropertiesOutput", + "SimpleUnion", + "SparseJsonListsInput", + "SparseJsonListsOutput", + "SparseJsonMapsInput", + "SparseJsonMapsOutput", + "StringEnum", + "StructureListMember", + "TestBodyStructureInput", + "TestBodyStructureOutput", + "TestConfig", + "TestEnum", + "TestGetNoInputNoPayloadInput", + "TestGetNoInputNoPayloadOutput", + "TestGetNoPayloadInput", + "TestGetNoPayloadOutput", + "TestIntEnum", + "TestPayloadBlobInput", + "TestPayloadBlobOutput", + "TestPayloadStructureInput", + "TestPayloadStructureOutput", + "TestPostNoInputNoPayloadInput", + "TestPostNoInputNoPayloadOutput", + "TestPostNoPayloadInput", + "TestPostNoPayloadOutput", + "TimestampFormatHeadersInput", + "TimestampFormatHeadersOutput", + "TopLevel", + "UnionPayload", + "UnionWithJsonName", + "Unit", + "UnitInputAndOutputInput", + "UnitInputAndOutputOutput", + } + ), + service_error="ServiceError", +) +del schemas, ModelRegistry, ModeledError + + +def __getattr__(name: str): + if (data := _OPERATIONS.get(name)) is not None: + return globals().setdefault(name, _registry.build_operation(name, *data)) + value = _registry.build(name) + globals()[name] = value + return value + + +def __dir__() -> list[str]: + return sorted({*globals(), *__all__}) diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/models.pyi b/codegen-output-py/rest-json-1-client/src/restjson_client/models.pyi new file mode 100644 index 000000000..6b542645e --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/models.pyi @@ -0,0 +1,4074 @@ +from collections.abc import Mapping, Sequence +from dataclasses import dataclass +from datetime import datetime +from enum import IntEnum, StrEnum +from typing import Required, Self, TypedDict + +from smithy_core.deserializers import ShapeDeserializer +from smithy_core.documents import Document +from smithy_core.exceptions import ModeledError +from smithy_core.response import ResponseMetadata +from smithy_core.schemas import APIOperation +from smithy_core.serializers import ShapeSerializer +from smithy_core.types import UnknownEnumMixin + +__all__ = [ + "ALL_QUERY_STRING_TYPES", + "CONSTANT_AND_VARIABLE_QUERY_STRING", + "CONSTANT_QUERY_STRING", + "CONTENT_TYPE_PARAMETERS", + "DATETIME_OFFSETS", + "DOCUMENT_TYPE", + "DOCUMENT_TYPE_AS_MAP_VALUE", + "DOCUMENT_TYPE_AS_PAYLOAD", + "EMPTY_INPUT_AND_EMPTY_OUTPUT", + "ENDPOINT_OPERATION", + "ENDPOINT_WITH_HOST_LABEL_OPERATION", + "FRACTIONAL_SECONDS", + "GREETING_WITH_ERRORS", + "HOST_WITH_PATH_OPERATION", + "HTTP_CHECKSUM_REQUIRED", + "HTTP_EMPTY_PREFIX_HEADERS", + "HTTP_ENUM_PAYLOAD", + "HTTP_PAYLOAD_TRAITS", + "HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE", + "HTTP_PAYLOAD_WITH_STRUCTURE", + "HTTP_PAYLOAD_WITH_UNION", + "HTTP_PREFIX_HEADERS", + "HTTP_PREFIX_HEADERS_IN_RESPONSE", + "HTTP_QUERY_PARAMS_ONLY_OPERATION", + "HTTP_REQUEST_WITH_FLOAT_LABELS", + "HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH", + "HTTP_REQUEST_WITH_LABELS", + "HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT", + "HTTP_REQUEST_WITH_REGEX_LITERAL", + "HTTP_RESPONSE_CODE", + "HTTP_STRING_PAYLOAD", + "IGNORE_QUERY_PARAMS_IN_RESPONSE", + "INPUT_AND_OUTPUT_WITH_HEADERS", + "JSON_BLOBS", + "JSON_ENUMS", + "JSON_INT_ENUMS", + "JSON_LISTS", + "JSON_MAPS", + "JSON_TIMESTAMPS", + "JSON_UNIONS", + "MALFORMED_ACCEPT_WITH_BODY", + "MALFORMED_ACCEPT_WITH_GENERIC_STRING", + "MALFORMED_ACCEPT_WITH_PAYLOAD", + "MALFORMED_BLOB", + "MALFORMED_BOOLEAN", + "MALFORMED_BYTE", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY", + "MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT", + "MALFORMED_CONTENT_TYPE_WITH_BODY", + "MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING", + "MALFORMED_CONTENT_TYPE_WITH_PAYLOAD", + "MALFORMED_DOUBLE", + "MALFORMED_FLOAT", + "MALFORMED_INTEGER", + "MALFORMED_LIST", + "MALFORMED_LONG", + "MALFORMED_MAP", + "MALFORMED_REQUEST_BODY", + "MALFORMED_SHORT", + "MALFORMED_STRING", + "MALFORMED_TIMESTAMP_BODY_DATE_TIME", + "MALFORMED_TIMESTAMP_BODY_DEFAULT", + "MALFORMED_TIMESTAMP_BODY_HTTP_DATE", + "MALFORMED_TIMESTAMP_HEADER_DATE_TIME", + "MALFORMED_TIMESTAMP_HEADER_DEFAULT", + "MALFORMED_TIMESTAMP_HEADER_EPOCH", + "MALFORMED_TIMESTAMP_PATH_DEFAULT", + "MALFORMED_TIMESTAMP_PATH_EPOCH", + "MALFORMED_TIMESTAMP_PATH_HTTP_DATE", + "MALFORMED_TIMESTAMP_QUERY_DEFAULT", + "MALFORMED_TIMESTAMP_QUERY_EPOCH", + "MALFORMED_TIMESTAMP_QUERY_HTTP_DATE", + "MALFORMED_UNION", + "MEDIA_TYPE_HEADER", + "NO_INPUT_AND_NO_OUTPUT", + "NO_INPUT_AND_OUTPUT", + "NULL_AND_EMPTY_HEADERS_CLIENT", + "NULL_AND_EMPTY_HEADERS_SERVER", + "OMITS_NULL_SERIALIZES_EMPTY_STRING", + "OMITS_SERIALIZING_EMPTY_LISTS", + "OPERATION_WITH_DEFAULTS", + "OPERATION_WITH_NESTED_STRUCTURE", + "POST_PLAYER_ACTION", + "POST_UNION_WITH_JSON_NAME", + "PUT_WITH_CONTENT_ENCODING", + "QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL", + "QUERY_PARAMS_AS_STRING_LIST_MAP", + "QUERY_PRECEDENCE", + "RECURSIVE_SHAPES", + "RESPONSE_CODE_HTTP_FALLBACK", + "RESPONSE_CODE_REQUIRED", + "SIMPLE_SCALAR_PROPERTIES", + "SPARSE_JSON_LISTS", + "SPARSE_JSON_MAPS", + "TEST_BODY_STRUCTURE", + "TEST_GET_NO_INPUT_NO_PAYLOAD", + "TEST_GET_NO_PAYLOAD", + "TEST_PAYLOAD_BLOB", + "TEST_PAYLOAD_STRUCTURE", + "TEST_POST_NO_INPUT_NO_PAYLOAD", + "TEST_POST_NO_PAYLOAD", + "TIMESTAMP_FORMAT_HEADERS", + "UNIT_INPUT_AND_OUTPUT", + "AllQueryStringTypesInput", + "AllQueryStringTypesOutput", + "ClientOptionalDefaults", + "ComplexError", + "ComplexNestedErrorData", + "ConstantAndVariableQueryStringInput", + "ConstantAndVariableQueryStringOutput", + "ConstantQueryStringInput", + "ConstantQueryStringOutput", + "ContentTypeParametersInput", + "ContentTypeParametersOutput", + "DatetimeOffsetsInput", + "DatetimeOffsetsOutput", + "Defaults", + "Dialog", + "DocumentTypeAsMapValueInput", + "DocumentTypeAsMapValueOutput", + "DocumentTypeAsPayloadInput", + "DocumentTypeAsPayloadOutput", + "DocumentTypeInput", + "DocumentTypeOutput", + "EmptyInputAndEmptyOutputInput", + "EmptyInputAndEmptyOutputOutput", + "EndpointOperationInput", + "EndpointOperationOutput", + "EndpointWithHostLabelOperationInput", + "EndpointWithHostLabelOperationOutput", + "Farewell", + "FooEnum", + "FooError", + "FractionalSecondsInput", + "FractionalSecondsOutput", + "GreetingStruct", + "GreetingWithErrorsInput", + "GreetingWithErrorsOutput", + "HostWithPathOperationInput", + "HostWithPathOperationOutput", + "HttpChecksumRequiredInput", + "HttpChecksumRequiredOutput", + "HttpEmptyPrefixHeadersInput", + "HttpEmptyPrefixHeadersOutput", + "HttpEnumPayloadInput", + "HttpEnumPayloadOutput", + "HttpPayloadTraitsInput", + "HttpPayloadTraitsOutput", + "HttpPayloadTraitsWithMediaTypeInput", + "HttpPayloadTraitsWithMediaTypeOutput", + "HttpPayloadWithStructureInput", + "HttpPayloadWithStructureOutput", + "HttpPayloadWithUnionInput", + "HttpPayloadWithUnionOutput", + "HttpPrefixHeadersInResponseInput", + "HttpPrefixHeadersInResponseOutput", + "HttpPrefixHeadersInput", + "HttpPrefixHeadersOutput", + "HttpQueryParamsOnlyOperationInput", + "HttpQueryParamsOnlyOperationOutput", + "HttpRequestWithFloatLabelsInput", + "HttpRequestWithFloatLabelsOutput", + "HttpRequestWithGreedyLabelInPathInput", + "HttpRequestWithGreedyLabelInPathOutput", + "HttpRequestWithLabelsAndTimestampFormatInput", + "HttpRequestWithLabelsAndTimestampFormatOutput", + "HttpRequestWithLabelsInput", + "HttpRequestWithLabelsOutput", + "HttpRequestWithRegexLiteralInput", + "HttpRequestWithRegexLiteralOutput", + "HttpResponseCodeInput", + "HttpResponseCodeOutput", + "HttpStringPayloadInput", + "HttpStringPayloadOutput", + "IgnoreQueryParamsInResponseInput", + "IgnoreQueryParamsInResponseOutput", + "InputAndOutputWithHeadersInput", + "InputAndOutputWithHeadersOutput", + "IntegerEnum", + "InvalidGreeting", + "JsonBlobsInput", + "JsonBlobsOutput", + "JsonEnumsInput", + "JsonEnumsOutput", + "JsonIntEnumsInput", + "JsonIntEnumsOutput", + "JsonListsInput", + "JsonListsOutput", + "JsonMapsInput", + "JsonMapsOutput", + "JsonTimestampsInput", + "JsonTimestampsOutput", + "JsonUnionsInput", + "JsonUnionsOutput", + "MalformedAcceptWithBodyInput", + "MalformedAcceptWithBodyOutput", + "MalformedAcceptWithGenericStringInput", + "MalformedAcceptWithGenericStringOutput", + "MalformedAcceptWithPayloadInput", + "MalformedAcceptWithPayloadOutput", + "MalformedBlobInput", + "MalformedBlobOutput", + "MalformedBooleanInput", + "MalformedBooleanOutput", + "MalformedByteInput", + "MalformedByteOutput", + "MalformedContentTypeWithBodyInput", + "MalformedContentTypeWithBodyOutput", + "MalformedContentTypeWithGenericStringInput", + "MalformedContentTypeWithGenericStringOutput", + "MalformedContentTypeWithPayloadInput", + "MalformedContentTypeWithPayloadOutput", + "MalformedContentTypeWithoutBodyEmptyInputInput", + "MalformedContentTypeWithoutBodyEmptyInputOutput", + "MalformedContentTypeWithoutBodyInput", + "MalformedContentTypeWithoutBodyOutput", + "MalformedDoubleInput", + "MalformedDoubleOutput", + "MalformedFloatInput", + "MalformedFloatOutput", + "MalformedIntegerInput", + "MalformedIntegerOutput", + "MalformedListInput", + "MalformedListOutput", + "MalformedLongInput", + "MalformedLongOutput", + "MalformedMapInput", + "MalformedMapOutput", + "MalformedRequestBodyInput", + "MalformedRequestBodyOutput", + "MalformedShortInput", + "MalformedShortOutput", + "MalformedStringInput", + "MalformedStringOutput", + "MalformedTimestampBodyDateTimeInput", + "MalformedTimestampBodyDateTimeOutput", + "MalformedTimestampBodyDefaultInput", + "MalformedTimestampBodyDefaultOutput", + "MalformedTimestampBodyHttpDateInput", + "MalformedTimestampBodyHttpDateOutput", + "MalformedTimestampHeaderDateTimeInput", + "MalformedTimestampHeaderDateTimeOutput", + "MalformedTimestampHeaderDefaultInput", + "MalformedTimestampHeaderDefaultOutput", + "MalformedTimestampHeaderEpochInput", + "MalformedTimestampHeaderEpochOutput", + "MalformedTimestampPathDefaultInput", + "MalformedTimestampPathDefaultOutput", + "MalformedTimestampPathEpochInput", + "MalformedTimestampPathEpochOutput", + "MalformedTimestampPathHttpDateInput", + "MalformedTimestampPathHttpDateOutput", + "MalformedTimestampQueryDefaultInput", + "MalformedTimestampQueryDefaultOutput", + "MalformedTimestampQueryEpochInput", + "MalformedTimestampQueryEpochOutput", + "MalformedTimestampQueryHttpDateInput", + "MalformedTimestampQueryHttpDateOutput", + "MalformedUnionInput", + "MalformedUnionOutput", + "MediaTypeHeaderInput", + "MediaTypeHeaderOutput", + "MyUnion", + "MyUnionBlobValue", + "MyUnionBooleanValue", + "MyUnionEnumValue", + "MyUnionListValue", + "MyUnionMapValue", + "MyUnionNumberValue", + "MyUnionRenamedStructureValue", + "MyUnionStringValue", + "MyUnionStructureValue", + "MyUnionTimestampValue", + "MyUnionUnionValue", + "MyUnionUnknown", + "NestedPayload", + "NestedUnion", + "NestedUnionStringValue", + "NestedUnionUnknown", + "NoInputAndNoOutputInput", + "NoInputAndNoOutputOutput", + "NoInputAndOutputInput", + "NoInputAndOutputOutput", + "NullAndEmptyHeadersClientInput", + "NullAndEmptyHeadersClientOutput", + "NullAndEmptyHeadersServerInput", + "NullAndEmptyHeadersServerOutput", + "OmitsNullSerializesEmptyStringInput", + "OmitsNullSerializesEmptyStringOutput", + "OmitsSerializingEmptyListsInput", + "OmitsSerializingEmptyListsOutput", + "OperationWithDefaultsInput", + "OperationWithDefaultsOutput", + "OperationWithNestedStructureInput", + "OperationWithNestedStructureOutput", + "PayloadConfig", + "PlayerAction", + "PlayerActionQuit", + "PlayerActionUnknown", + "PostPlayerActionInput", + "PostPlayerActionOutput", + "PostUnionWithJsonNameInput", + "PostUnionWithJsonNameOutput", + "PutWithContentEncodingInput", + "PutWithContentEncodingOutput", + "QueryIdempotencyTokenAutoFillInput", + "QueryIdempotencyTokenAutoFillOutput", + "QueryParamsAsStringListMapInput", + "QueryParamsAsStringListMapOutput", + "QueryPrecedenceInput", + "QueryPrecedenceOutput", + "RecursiveShapesInput", + "RecursiveShapesInputOutputNested1", + "RecursiveShapesInputOutputNested2", + "RecursiveShapesOutput", + "RenamedGreeting", + "ResponseCodeHttpFallbackInput", + "ResponseCodeHttpFallbackOutput", + "ResponseCodeRequiredInput", + "ResponseCodeRequiredOutput", + "ServiceError", + "SimpleScalarPropertiesInput", + "SimpleScalarPropertiesOutput", + "SimpleUnion", + "SimpleUnionInt", + "SimpleUnionString", + "SimpleUnionUnknown", + "SparseJsonListsInput", + "SparseJsonListsOutput", + "SparseJsonMapsInput", + "SparseJsonMapsOutput", + "StringEnum", + "StructureListMember", + "TestBodyStructureInput", + "TestBodyStructureOutput", + "TestConfig", + "TestEnum", + "TestGetNoInputNoPayloadInput", + "TestGetNoInputNoPayloadOutput", + "TestGetNoPayloadInput", + "TestGetNoPayloadOutput", + "TestIntEnum", + "TestPayloadBlobInput", + "TestPayloadBlobOutput", + "TestPayloadStructureInput", + "TestPayloadStructureOutput", + "TestPostNoInputNoPayloadInput", + "TestPostNoInputNoPayloadOutput", + "TestPostNoPayloadInput", + "TestPostNoPayloadOutput", + "TimestampFormatHeadersInput", + "TimestampFormatHeadersOutput", + "TopLevel", + "UnionPayload", + "UnionPayloadGreeting", + "UnionPayloadUnknown", + "UnionWithJsonName", + "UnionWithJsonNameBar", + "UnionWithJsonNameBaz", + "UnionWithJsonNameFoo", + "UnionWithJsonNameUnknown", + "Unit", + "UnitInputAndOutputInput", + "UnitInputAndOutputOutput", +] + +class _SerdeShape: + def serialize(self, serializer: ShapeSerializer) -> None: ... + def serialize_members(self, serializer: ShapeSerializer) -> None: ... + @classmethod + def deserialize(cls, deserializer: ShapeDeserializer) -> Self: ... + +class ServiceError(ModeledError): + """ + Base error for all errors in the service. + + Some exceptions do not extend from this class, including synthetic, + implicit, and shared exception types. + """ + +@dataclass(kw_only=True) +class AllQueryStringTypesInput(_SerdeShape): + "Dataclass for AllQueryStringTypesInput structure." + + query_string: str | None = ... + query_string_list: list[str] | None = ... + query_string_set: list[str] | None = ... + query_byte: int | None = ... + query_short: int | None = ... + query_integer: int | None = ... + query_integer_list: list[int] | None = ... + query_integer_set: list[int] | None = ... + query_long: int | None = ... + query_float: float | None = ... + query_double: float | None = ... + query_double_list: list[float] | None = ... + query_boolean: bool | None = ... + query_boolean_list: list[bool] | None = ... + query_timestamp: datetime | None = ... + query_timestamp_list: list[datetime] | None = ... + query_enum: str | None = ... + query_enum_list: list[str] | None = ... + query_integer_enum: int | None = ... + query_integer_enum_list: list[int] | None = ... + query_params_map_of_string_list: dict[str, list[str]] | None = ... + +class AllQueryStringTypesInputDict(TypedDict, total=False): + "Dictionary form of `AllQueryStringTypesInput`." + + query_string: str | None + query_string_list: Sequence[str] | None + query_string_set: Sequence[str] | None + query_byte: int | None + query_short: int | None + query_integer: int | None + query_integer_list: Sequence[int] | None + query_integer_set: Sequence[int] | None + query_long: int | None + query_float: float | None + query_double: float | None + query_double_list: Sequence[float] | None + query_boolean: bool | None + query_boolean_list: Sequence[bool] | None + query_timestamp: datetime | None + query_timestamp_list: Sequence[datetime] | None + query_enum: str | None + query_enum_list: Sequence[str] | None + query_integer_enum: int | None + query_integer_enum_list: Sequence[int] | None + query_params_map_of_string_list: Mapping[str, Sequence[str]] | None + +@dataclass(kw_only=True) +class ClientOptionalDefaults(_SerdeShape): + "Dataclass for ClientOptionalDefaults structure." + + member: int | None = ... + +class ClientOptionalDefaultsDict(TypedDict, total=False): + "Dictionary form of `ClientOptionalDefaults`." + + member: int | None + +@dataclass(kw_only=True) +class ComplexError(ServiceError, _SerdeShape): + "This error is thrown when a request is invalid." + + header: str | None = ... + top_level: str | None = ... + nested: ComplexNestedErrorData | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class ComplexNestedErrorData(_SerdeShape): + "Dataclass for ComplexNestedErrorData structure." + + foo: str | None = ... + +@dataclass(kw_only=True) +class ConstantAndVariableQueryStringInput(_SerdeShape): + "Dataclass for ConstantAndVariableQueryStringInput structure." + + baz: str | None = ... + maybe_set: str | None = ... + +class ConstantAndVariableQueryStringInputDict(TypedDict, total=False): + "Dictionary form of `ConstantAndVariableQueryStringInput`." + + baz: str | None + maybe_set: str | None + +@dataclass(kw_only=True) +class ConstantQueryStringInput(_SerdeShape): + "Dataclass for ConstantQueryStringInput structure." + + hello: str | None = ... + +class ConstantQueryStringInputDict(TypedDict, total=False): + "Dictionary form of `ConstantQueryStringInput`." + + hello: Required[str] + +@dataclass(kw_only=True) +class ContentTypeParametersInput(_SerdeShape): + "Dataclass for ContentTypeParametersInput structure." + + value: int | None = ... + +class ContentTypeParametersInputDict(TypedDict, total=False): + "Dictionary form of `ContentTypeParametersInput`." + + value: int | None + +@dataclass(kw_only=True) +class ContentTypeParametersOutput(_SerdeShape): + "Dataclass for ContentTypeParametersOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class DatetimeOffsetsOutput(_SerdeShape): + "Dataclass for DatetimeOffsetsOutput structure." + + datetime_: datetime | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class Defaults(_SerdeShape): + "Dataclass for Defaults structure." + + default_string: str | None = ... + default_boolean: bool | None = ... + default_list: list[str] | None = ... + default_document_map: Document | None = ... + default_document_string: Document | None = ... + default_document_boolean: Document | None = ... + default_document_list: Document | None = ... + default_null_document: Document | None = ... + default_timestamp: datetime | None = ... + default_blob: bytes | None = ... + default_byte: int | None = ... + default_short: int | None = ... + default_integer: int | None = ... + default_long: int | None = ... + default_float: float | None = ... + default_double: float | None = ... + default_map: dict[str, str] | None = ... + default_enum: str | None = ... + default_int_enum: int | None = ... + empty_string: str | None = ... + false_boolean: bool | None = ... + empty_blob: bytes | None = ... + zero_byte: int | None = ... + zero_short: int | None = ... + zero_integer: int | None = ... + zero_long: int | None = ... + zero_float: float | None = ... + zero_double: float | None = ... + +class DefaultsDict(TypedDict, total=False): + "Dictionary form of `Defaults`." + + default_string: str | None + default_boolean: bool | None + default_list: Sequence[str] | None + default_document_map: Document | None + default_document_string: Document | None + default_document_boolean: Document | None + default_document_list: Document | None + default_null_document: Document | None + default_timestamp: datetime | None + default_blob: bytes | None + default_byte: int | None + default_short: int | None + default_integer: int | None + default_long: int | None + default_float: float | None + default_double: float | None + default_map: Mapping[str, str] | None + default_enum: str | None + default_int_enum: int | None + empty_string: str | None + false_boolean: bool | None + empty_blob: bytes | None + zero_byte: int | None + zero_short: int | None + zero_integer: int | None + zero_long: int | None + zero_float: float | None + zero_double: float | None + +@dataclass(kw_only=True) +class Dialog(_SerdeShape): + "Dataclass for Dialog structure." + + language: str | None = ... + greeting: str | None = ... + farewell: Farewell | None = ... + +class DialogDict(TypedDict, total=False): + "Dictionary form of `Dialog`." + + language: str | None + greeting: str | None + farewell: Farewell | FarewellDict | None + +@dataclass(kw_only=True) +class EmptyInputAndEmptyOutputInput(_SerdeShape): + "Dataclass for EmptyInputAndEmptyOutputInput structure." + +class EmptyInputAndEmptyOutputInputDict(TypedDict, total=False): + "Dictionary form of `EmptyInputAndEmptyOutputInput`." + +@dataclass(kw_only=True) +class EmptyInputAndEmptyOutputOutput(_SerdeShape): + "Dataclass for EmptyInputAndEmptyOutputOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class Farewell(_SerdeShape): + "Dataclass for Farewell structure." + + phrase: str | None = ... + +class FarewellDict(TypedDict, total=False): + "Dictionary form of `Farewell`." + + phrase: str | None + +@dataclass(kw_only=True) +class FooError(ServiceError, _SerdeShape): + """ + This error has test cases that test some of the dark corners of Amazon + service + framework history. It should only be implemented by clients. + """ + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class FractionalSecondsOutput(_SerdeShape): + "Dataclass for FractionalSecondsOutput structure." + + datetime_: datetime | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class GreetingWithErrorsOutput(_SerdeShape): + "Dataclass for GreetingWithErrorsOutput structure." + + greeting: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpEmptyPrefixHeadersInput(_SerdeShape): + "Dataclass for HttpEmptyPrefixHeadersInput structure." + + prefix_headers: dict[str, str] | None = ... + specific_header: str | None = ... + +class HttpEmptyPrefixHeadersInputDict(TypedDict, total=False): + "Dictionary form of `HttpEmptyPrefixHeadersInput`." + + prefix_headers: Mapping[str, str] | None + specific_header: str | None + +@dataclass(kw_only=True) +class HttpEmptyPrefixHeadersOutput(_SerdeShape): + "Dataclass for HttpEmptyPrefixHeadersOutput structure." + + prefix_headers: dict[str, str] | None = ... + specific_header: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpPrefixHeadersInResponseInput(_SerdeShape): + "Dataclass for HttpPrefixHeadersInResponseInput structure." + +class HttpPrefixHeadersInResponseInputDict(TypedDict, total=False): + "Dictionary form of `HttpPrefixHeadersInResponseInput`." + +@dataclass(kw_only=True) +class HttpPrefixHeadersInResponseOutput(_SerdeShape): + "Dataclass for HttpPrefixHeadersInResponseOutput structure." + + prefix_headers: dict[str, str] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpPrefixHeadersInput(_SerdeShape): + "Dataclass for HttpPrefixHeadersInput structure." + + foo: str | None = ... + foo_map: dict[str, str] | None = ... + +class HttpPrefixHeadersInputDict(TypedDict, total=False): + "Dictionary form of `HttpPrefixHeadersInput`." + + foo: str | None + foo_map: Mapping[str, str] | None + +@dataclass(kw_only=True) +class HttpPrefixHeadersOutput(_SerdeShape): + "Dataclass for HttpPrefixHeadersOutput structure." + + foo: str | None = ... + foo_map: dict[str, str] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpRequestWithFloatLabelsInput(_SerdeShape): + "Dataclass for HttpRequestWithFloatLabelsInput structure." + + float_: float | None = ... + double: float | None = ... + +class HttpRequestWithFloatLabelsInputDict(TypedDict, total=False): + "Dictionary form of `HttpRequestWithFloatLabelsInput`." + + float_: Required[float] + double: Required[float] + +@dataclass(kw_only=True) +class HttpRequestWithGreedyLabelInPathInput(_SerdeShape): + "Dataclass for HttpRequestWithGreedyLabelInPathInput structure." + + foo: str | None = ... + baz: str | None = ... + +class HttpRequestWithGreedyLabelInPathInputDict(TypedDict, total=False): + "Dictionary form of `HttpRequestWithGreedyLabelInPathInput`." + + foo: Required[str] + baz: Required[str] + +@dataclass(kw_only=True) +class HttpRequestWithLabelsAndTimestampFormatInput(_SerdeShape): + "Dataclass for HttpRequestWithLabelsAndTimestampFormatInput structure." + + member_epoch_seconds: datetime | None = ... + member_http_date: datetime | None = ... + member_date_time: datetime | None = ... + default_format: datetime | None = ... + target_epoch_seconds: datetime | None = ... + target_http_date: datetime | None = ... + target_date_time: datetime | None = ... + +class HttpRequestWithLabelsAndTimestampFormatInputDict(TypedDict, total=False): + "Dictionary form of `HttpRequestWithLabelsAndTimestampFormatInput`." + + member_epoch_seconds: Required[datetime] + member_http_date: Required[datetime] + member_date_time: Required[datetime] + default_format: Required[datetime] + target_epoch_seconds: Required[datetime] + target_http_date: Required[datetime] + target_date_time: Required[datetime] + +@dataclass(kw_only=True) +class HttpRequestWithLabelsInput(_SerdeShape): + "Dataclass for HttpRequestWithLabelsInput structure." + + string: str | None = ... + short: int | None = ... + integer: int | None = ... + long: int | None = ... + float_: float | None = ... + double: float | None = ... + boolean: bool | None = ... + "Serialized in the path as true or false." + timestamp: datetime | None = ... + """ + Note that this member has no format, so it's serialized as an RFC 3399 + date-time. + """ + +class HttpRequestWithLabelsInputDict(TypedDict, total=False): + "Dictionary form of `HttpRequestWithLabelsInput`." + + string: Required[str] + short: Required[int] + integer: Required[int] + long: Required[int] + float_: Required[float] + double: Required[float] + boolean: Required[bool] + "Serialized in the path as true or false." + timestamp: Required[datetime] + """ + Note that this member has no format, so it's serialized as an RFC 3399 + date-time. + """ + +@dataclass(kw_only=True) +class HttpRequestWithRegexLiteralInput(_SerdeShape): + "Dataclass for HttpRequestWithRegexLiteralInput structure." + + str_: str | None = ... + +class HttpRequestWithRegexLiteralInputDict(TypedDict, total=False): + "Dictionary form of `HttpRequestWithRegexLiteralInput`." + + str_: Required[str] + +@dataclass(kw_only=True) +class HttpResponseCodeOutput(_SerdeShape): + "Dataclass for HttpResponseCodeOutput structure." + + status: int | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class IgnoreQueryParamsInResponseOutput(_SerdeShape): + "Dataclass for IgnoreQueryParamsInResponseOutput structure." + + baz: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class InvalidGreeting(ServiceError, _SerdeShape): + "This error is thrown when an invalid greeting value is provided." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedAcceptWithGenericStringOutput(_SerdeShape): + "Dataclass for MalformedAcceptWithGenericStringOutput structure." + + payload: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedAcceptWithPayloadOutput(_SerdeShape): + "Dataclass for MalformedAcceptWithPayloadOutput structure." + + payload: bytes | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedBlobInput(_SerdeShape): + "Dataclass for MalformedBlobInput structure." + + blob: bytes | None = ... + +class MalformedBlobInputDict(TypedDict, total=False): + "Dictionary form of `MalformedBlobInput`." + + blob: bytes | None + +@dataclass(kw_only=True) +class MalformedBooleanInput(_SerdeShape): + "Dataclass for MalformedBooleanInput structure." + + boolean_in_body: bool | None = ... + boolean_in_path: bool | None = ... + boolean_in_query: bool | None = ... + boolean_in_header: bool | None = ... + +class MalformedBooleanInputDict(TypedDict, total=False): + "Dictionary form of `MalformedBooleanInput`." + + boolean_in_body: bool | None + boolean_in_path: Required[bool] + boolean_in_query: bool | None + boolean_in_header: bool | None + +@dataclass(kw_only=True) +class MalformedByteInput(_SerdeShape): + "Dataclass for MalformedByteInput structure." + + byte_in_body: int | None = ... + byte_in_path: int | None = ... + byte_in_query: int | None = ... + byte_in_header: int | None = ... + +class MalformedByteInputDict(TypedDict, total=False): + "Dictionary form of `MalformedByteInput`." + + byte_in_body: int | None + byte_in_path: Required[int] + byte_in_query: int | None + byte_in_header: int | None + +@dataclass(kw_only=True) +class MalformedContentTypeWithGenericStringInput(_SerdeShape): + "Dataclass for MalformedContentTypeWithGenericStringInput structure." + + payload: str | None = ... + +class MalformedContentTypeWithGenericStringInputDict(TypedDict, total=False): + "Dictionary form of `MalformedContentTypeWithGenericStringInput`." + + payload: str | None + +@dataclass(kw_only=True) +class MalformedContentTypeWithPayloadInput(_SerdeShape): + "Dataclass for MalformedContentTypeWithPayloadInput structure." + + payload: bytes | None = ... + +class MalformedContentTypeWithPayloadInputDict(TypedDict, total=False): + "Dictionary form of `MalformedContentTypeWithPayloadInput`." + + payload: bytes | None + +@dataclass(kw_only=True) +class MalformedContentTypeWithoutBodyEmptyInputInput(_SerdeShape): + "Dataclass for MalformedContentTypeWithoutBodyEmptyInputInput structure." + + header: str | None = ... + +class MalformedContentTypeWithoutBodyEmptyInputInputDict(TypedDict, total=False): + "Dictionary form of `MalformedContentTypeWithoutBodyEmptyInputInput`." + + header: str | None + +@dataclass(kw_only=True) +class MalformedDoubleInput(_SerdeShape): + "Dataclass for MalformedDoubleInput structure." + + double_in_body: float | None = ... + double_in_path: float | None = ... + double_in_query: float | None = ... + double_in_header: float | None = ... + +class MalformedDoubleInputDict(TypedDict, total=False): + "Dictionary form of `MalformedDoubleInput`." + + double_in_body: float | None + double_in_path: Required[float] + double_in_query: float | None + double_in_header: float | None + +@dataclass(kw_only=True) +class MalformedFloatInput(_SerdeShape): + "Dataclass for MalformedFloatInput structure." + + float_in_body: float | None = ... + float_in_path: float | None = ... + float_in_query: float | None = ... + float_in_header: float | None = ... + +class MalformedFloatInputDict(TypedDict, total=False): + "Dictionary form of `MalformedFloatInput`." + + float_in_body: float | None + float_in_path: Required[float] + float_in_query: float | None + float_in_header: float | None + +@dataclass(kw_only=True) +class MalformedIntegerInput(_SerdeShape): + "Dataclass for MalformedIntegerInput structure." + + integer_in_body: int | None = ... + integer_in_path: int | None = ... + integer_in_query: int | None = ... + integer_in_header: int | None = ... + +class MalformedIntegerInputDict(TypedDict, total=False): + "Dictionary form of `MalformedIntegerInput`." + + integer_in_body: int | None + integer_in_path: Required[int] + integer_in_query: int | None + integer_in_header: int | None + +@dataclass(kw_only=True) +class MalformedListInput(_SerdeShape): + "Dataclass for MalformedListInput structure." + + body_list: list[str] | None = ... + +class MalformedListInputDict(TypedDict, total=False): + "Dictionary form of `MalformedListInput`." + + body_list: Sequence[str] | None + +@dataclass(kw_only=True) +class MalformedLongInput(_SerdeShape): + "Dataclass for MalformedLongInput structure." + + long_in_body: int | None = ... + long_in_path: int | None = ... + long_in_query: int | None = ... + long_in_header: int | None = ... + +class MalformedLongInputDict(TypedDict, total=False): + "Dictionary form of `MalformedLongInput`." + + long_in_body: int | None + long_in_path: Required[int] + long_in_query: int | None + long_in_header: int | None + +@dataclass(kw_only=True) +class MalformedMapInput(_SerdeShape): + "Dataclass for MalformedMapInput structure." + + body_map: dict[str, str] | None = ... + +class MalformedMapInputDict(TypedDict, total=False): + "Dictionary form of `MalformedMapInput`." + + body_map: Mapping[str, str] | None + +@dataclass(kw_only=True) +class MalformedRequestBodyInput(_SerdeShape): + "Dataclass for MalformedRequestBodyInput structure." + + int_: int | None = ... + float_: float | None = ... + +class MalformedRequestBodyInputDict(TypedDict, total=False): + "Dictionary form of `MalformedRequestBodyInput`." + + int_: int | None + float_: float | None + +@dataclass(kw_only=True) +class MalformedShortInput(_SerdeShape): + "Dataclass for MalformedShortInput structure." + + short_in_body: int | None = ... + short_in_path: int | None = ... + short_in_query: int | None = ... + short_in_header: int | None = ... + +class MalformedShortInputDict(TypedDict, total=False): + "Dictionary form of `MalformedShortInput`." + + short_in_body: int | None + short_in_path: Required[int] + short_in_query: int | None + short_in_header: int | None + +@dataclass(kw_only=True) +class MalformedStringInput(_SerdeShape): + "Dataclass for MalformedStringInput structure." + + blob: str | None = ... + +class MalformedStringInputDict(TypedDict, total=False): + "Dictionary form of `MalformedStringInput`." + + blob: str | None + +@dataclass(kw_only=True) +class MalformedTimestampBodyDateTimeInput(_SerdeShape): + "Dataclass for MalformedTimestampBodyDateTimeInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampBodyDateTimeInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampBodyDateTimeInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampBodyDefaultInput(_SerdeShape): + "Dataclass for MalformedTimestampBodyDefaultInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampBodyDefaultInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampBodyDefaultInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampBodyHttpDateInput(_SerdeShape): + "Dataclass for MalformedTimestampBodyHttpDateInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampBodyHttpDateInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampBodyHttpDateInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampHeaderDateTimeInput(_SerdeShape): + "Dataclass for MalformedTimestampHeaderDateTimeInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampHeaderDateTimeInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampHeaderDateTimeInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampHeaderDefaultInput(_SerdeShape): + "Dataclass for MalformedTimestampHeaderDefaultInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampHeaderDefaultInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampHeaderDefaultInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampHeaderEpochInput(_SerdeShape): + "Dataclass for MalformedTimestampHeaderEpochInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampHeaderEpochInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampHeaderEpochInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampPathDefaultInput(_SerdeShape): + "Dataclass for MalformedTimestampPathDefaultInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampPathDefaultInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampPathDefaultInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampPathEpochInput(_SerdeShape): + "Dataclass for MalformedTimestampPathEpochInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampPathEpochInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampPathEpochInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampPathHttpDateInput(_SerdeShape): + "Dataclass for MalformedTimestampPathHttpDateInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampPathHttpDateInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampPathHttpDateInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampQueryDefaultInput(_SerdeShape): + "Dataclass for MalformedTimestampQueryDefaultInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampQueryDefaultInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampQueryDefaultInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampQueryEpochInput(_SerdeShape): + "Dataclass for MalformedTimestampQueryEpochInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampQueryEpochInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampQueryEpochInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedTimestampQueryHttpDateInput(_SerdeShape): + "Dataclass for MalformedTimestampQueryHttpDateInput structure." + + timestamp: datetime | None = ... + +class MalformedTimestampQueryHttpDateInputDict(TypedDict, total=False): + "Dictionary form of `MalformedTimestampQueryHttpDateInput`." + + timestamp: Required[datetime] + +@dataclass(kw_only=True) +class MalformedUnionInput(_SerdeShape): + "Dataclass for MalformedUnionInput structure." + + union: SimpleUnion | None = ... + +class MalformedUnionInputDict(TypedDict, total=False): + "Dictionary form of `MalformedUnionInput`." + + union: SimpleUnion | SimpleUnionDict | None + +@dataclass(kw_only=True) +class MediaTypeHeaderInput(_SerdeShape): + "Dataclass for MediaTypeHeaderInput structure." + + json: str | None = ... + +class MediaTypeHeaderInputDict(TypedDict, total=False): + "Dictionary form of `MediaTypeHeaderInput`." + + json: str | None + +@dataclass(kw_only=True) +class MediaTypeHeaderOutput(_SerdeShape): + "Dataclass for MediaTypeHeaderOutput structure." + + json: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass +class MyUnionStringValue(_SerdeShape): + value: str + +@dataclass +class MyUnionBooleanValue(_SerdeShape): + value: bool + +@dataclass +class MyUnionNumberValue(_SerdeShape): + value: int + +@dataclass +class MyUnionBlobValue(_SerdeShape): + value: bytes + +@dataclass +class MyUnionTimestampValue(_SerdeShape): + value: datetime + +@dataclass +class MyUnionEnumValue(_SerdeShape): + value: str + +@dataclass +class MyUnionListValue(_SerdeShape): + value: list[str] + +@dataclass +class MyUnionMapValue(_SerdeShape): + value: dict[str, str] + +@dataclass +class MyUnionStructureValue(_SerdeShape): + value: GreetingStruct + +@dataclass +class MyUnionRenamedStructureValue(_SerdeShape): + value: RenamedGreeting + +@dataclass +class MyUnionUnionValue(_SerdeShape): + value: NestedUnion + +@dataclass +class MyUnionUnknown(_SerdeShape): + """ + Represents an unknown variant. + + If you receive this value, you will need to update your library to + receive the parsed value. + + This value may not be deliberately sent. + """ + + tag: str + +MyUnion = ( + MyUnionStringValue + | MyUnionBooleanValue + | MyUnionNumberValue + | MyUnionBlobValue + | MyUnionTimestampValue + | MyUnionEnumValue + | MyUnionListValue + | MyUnionMapValue + | MyUnionStructureValue + | MyUnionRenamedStructureValue + | MyUnionUnionValue + | MyUnionUnknown +) +"A union with a representative set of types for members." + +class _MyUnionDeserializer: + def deserialize(self, deserializer: ShapeDeserializer) -> MyUnion: ... + +class MyUnionStringValueDict(TypedDict): + string_value: str + +class MyUnionBooleanValueDict(TypedDict): + boolean_value: bool + +class MyUnionNumberValueDict(TypedDict): + number_value: int + +class MyUnionBlobValueDict(TypedDict): + blob_value: bytes + +class MyUnionTimestampValueDict(TypedDict): + timestamp_value: datetime + +class MyUnionEnumValueDict(TypedDict): + enum_value: str + +class MyUnionListValueDict(TypedDict): + list_value: Sequence[str] + +class MyUnionMapValueDict(TypedDict): + map_value: Mapping[str, str] + +class MyUnionStructureValueDict(TypedDict): + structure_value: GreetingStruct | GreetingStructDict + +class MyUnionRenamedStructureValueDict(TypedDict): + renamed_structure_value: RenamedGreeting | RenamedGreetingDict + +class MyUnionUnionValueDict(TypedDict): + union_value: NestedUnion | NestedUnionDict + +MyUnionDict = ( + MyUnionStringValueDict + | MyUnionBooleanValueDict + | MyUnionNumberValueDict + | MyUnionBlobValueDict + | MyUnionTimestampValueDict + | MyUnionEnumValueDict + | MyUnionListValueDict + | MyUnionMapValueDict + | MyUnionStructureValueDict + | MyUnionRenamedStructureValueDict + | MyUnionUnionValueDict +) +"Dictionary form of `MyUnion`, setting exactly one variant." + +@dataclass(kw_only=True) +class NestedPayload(_SerdeShape): + "Dataclass for NestedPayload structure." + + greeting: str | None = ... + name: str | None = ... + +class NestedPayloadDict(TypedDict, total=False): + "Dictionary form of `NestedPayload`." + + greeting: str | None + name: str | None + +@dataclass +class NestedUnionStringValue(_SerdeShape): + value: str + +@dataclass +class NestedUnionUnknown(_SerdeShape): + """ + Represents an unknown variant. + + If you receive this value, you will need to update your library to + receive the parsed value. + + This value may not be deliberately sent. + """ + + tag: str + +NestedUnion = NestedUnionStringValue | NestedUnionUnknown +"A union used to test unions nested inside unions." + +class _NestedUnionDeserializer: + def deserialize(self, deserializer: ShapeDeserializer) -> NestedUnion: ... + +class NestedUnionStringValueDict(TypedDict): + string_value: str + +NestedUnionDict = NestedUnionStringValueDict +"Dictionary form of `NestedUnion`, setting exactly one variant." + +@dataclass(kw_only=True) +class NoInputAndOutputOutput(_SerdeShape): + "Dataclass for NoInputAndOutputOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class OmitsNullSerializesEmptyStringInput(_SerdeShape): + "Dataclass for OmitsNullSerializesEmptyStringInput structure." + + null_value: str | None = ... + empty_string: str | None = ... + +class OmitsNullSerializesEmptyStringInputDict(TypedDict, total=False): + "Dictionary form of `OmitsNullSerializesEmptyStringInput`." + + null_value: str | None + empty_string: str | None + +@dataclass(kw_only=True) +class OmitsSerializingEmptyListsInput(_SerdeShape): + "Dataclass for OmitsSerializingEmptyListsInput structure." + + query_string_list: list[str] | None = ... + query_integer_list: list[int] | None = ... + query_double_list: list[float] | None = ... + query_boolean_list: list[bool] | None = ... + query_timestamp_list: list[datetime] | None = ... + query_enum_list: list[str] | None = ... + query_integer_enum_list: list[int] | None = ... + +class OmitsSerializingEmptyListsInputDict(TypedDict, total=False): + "Dictionary form of `OmitsSerializingEmptyListsInput`." + + query_string_list: Sequence[str] | None + query_integer_list: Sequence[int] | None + query_double_list: Sequence[float] | None + query_boolean_list: Sequence[bool] | None + query_timestamp_list: Sequence[datetime] | None + query_enum_list: Sequence[str] | None + query_integer_enum_list: Sequence[int] | None + +@dataclass(kw_only=True) +class OperationWithDefaultsInput(_SerdeShape): + "Dataclass for OperationWithDefaultsInput structure." + + defaults: Defaults | None = ... + client_optional_defaults: ClientOptionalDefaults | None = ... + top_level_default: str | None = ... + other_top_level_default: int | None = ... + +class OperationWithDefaultsInputDict(TypedDict, total=False): + "Dictionary form of `OperationWithDefaultsInput`." + + defaults: Defaults | DefaultsDict | None + client_optional_defaults: ClientOptionalDefaults | ClientOptionalDefaultsDict | None + top_level_default: str | None + other_top_level_default: int | None + +@dataclass(kw_only=True) +class OperationWithDefaultsOutput(_SerdeShape): + "Dataclass for OperationWithDefaultsOutput structure." + + default_string: str | None = ... + default_boolean: bool | None = ... + default_list: list[str] | None = ... + default_document_map: Document | None = ... + default_document_string: Document | None = ... + default_document_boolean: Document | None = ... + default_document_list: Document | None = ... + default_null_document: Document | None = ... + default_timestamp: datetime | None = ... + default_blob: bytes | None = ... + default_byte: int | None = ... + default_short: int | None = ... + default_integer: int | None = ... + default_long: int | None = ... + default_float: float | None = ... + default_double: float | None = ... + default_map: dict[str, str] | None = ... + default_enum: str | None = ... + default_int_enum: int | None = ... + empty_string: str | None = ... + false_boolean: bool | None = ... + empty_blob: bytes | None = ... + zero_byte: int | None = ... + zero_short: int | None = ... + zero_integer: int | None = ... + zero_long: int | None = ... + zero_float: float | None = ... + zero_double: float | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class OperationWithNestedStructureInput(_SerdeShape): + "Dataclass for OperationWithNestedStructureInput structure." + + top_level: TopLevel | None = ... + +class OperationWithNestedStructureInputDict(TypedDict, total=False): + "Dictionary form of `OperationWithNestedStructureInput`." + + top_level: Required[TopLevel | TopLevelDict] + +@dataclass(kw_only=True) +class OperationWithNestedStructureOutput(_SerdeShape): + "Dataclass for OperationWithNestedStructureOutput structure." + + dialog: Dialog + dialog_list: list[Dialog] | None = ... + dialog_map: dict[str, Dialog] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class PayloadConfig(_SerdeShape): + "Dataclass for PayloadConfig structure." + + data: int | None = ... + +class PayloadConfigDict(TypedDict, total=False): + "Dictionary form of `PayloadConfig`." + + data: int | None + +@dataclass +class PlayerActionQuit(_SerdeShape): + "Quit the game." + + value: Unit + +@dataclass +class PlayerActionUnknown(_SerdeShape): + """ + Represents an unknown variant. + + If you receive this value, you will need to update your library to + receive the parsed value. + + This value may not be deliberately sent. + """ + + tag: str + +PlayerAction = PlayerActionQuit | PlayerActionUnknown + +class _PlayerActionDeserializer: + def deserialize(self, deserializer: ShapeDeserializer) -> PlayerAction: ... + +class PlayerActionQuitDict(TypedDict): + quit: Unit | UnitDict + "Quit the game." + +PlayerActionDict = PlayerActionQuitDict +"Dictionary form of `PlayerAction`, setting exactly one variant." + +@dataclass(kw_only=True) +class PostPlayerActionInput(_SerdeShape): + "Dataclass for PostPlayerActionInput structure." + + action: PlayerAction | None = ... + +class PostPlayerActionInputDict(TypedDict, total=False): + "Dictionary form of `PostPlayerActionInput`." + + action: PlayerAction | PlayerActionDict | None + +@dataclass(kw_only=True) +class PostPlayerActionOutput(_SerdeShape): + "Dataclass for PostPlayerActionOutput structure." + + action: PlayerAction + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class PostUnionWithJsonNameInput(_SerdeShape): + "Dataclass for PostUnionWithJsonNameInput structure." + + value: UnionWithJsonName | None = ... + +class PostUnionWithJsonNameInputDict(TypedDict, total=False): + "Dictionary form of `PostUnionWithJsonNameInput`." + + value: UnionWithJsonName | UnionWithJsonNameDict | None + +@dataclass(kw_only=True) +class PostUnionWithJsonNameOutput(_SerdeShape): + "Dataclass for PostUnionWithJsonNameOutput structure." + + value: UnionWithJsonName + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class PutWithContentEncodingInput(_SerdeShape): + "Dataclass for PutWithContentEncodingInput structure." + + encoding: str | None = ... + data: str | None = ... + +class PutWithContentEncodingInputDict(TypedDict, total=False): + "Dictionary form of `PutWithContentEncodingInput`." + + encoding: str | None + data: str | None + +@dataclass(kw_only=True) +class QueryIdempotencyTokenAutoFillInput(_SerdeShape): + "Dataclass for QueryIdempotencyTokenAutoFillInput structure." + + token: str | None = ... + "This field is autopopulated if not provided." + +class QueryIdempotencyTokenAutoFillInputDict(TypedDict, total=False): + "Dictionary form of `QueryIdempotencyTokenAutoFillInput`." + + token: str | None + "This field is autopopulated if not provided." + +@dataclass(kw_only=True) +class QueryParamsAsStringListMapInput(_SerdeShape): + "Dataclass for QueryParamsAsStringListMapInput structure." + + qux: str | None = ... + foo: dict[str, list[str]] | None = ... + +class QueryParamsAsStringListMapInputDict(TypedDict, total=False): + "Dictionary form of `QueryParamsAsStringListMapInput`." + + qux: str | None + foo: Mapping[str, Sequence[str]] | None + +@dataclass(kw_only=True) +class QueryPrecedenceInput(_SerdeShape): + "Dataclass for QueryPrecedenceInput structure." + + foo: str | None = ... + baz: dict[str, str] | None = ... + +class QueryPrecedenceInputDict(TypedDict, total=False): + "Dictionary form of `QueryPrecedenceInput`." + + foo: str | None + baz: Mapping[str, str] | None + +@dataclass(kw_only=True) +class RecursiveShapesInputOutputNested1(_SerdeShape): + "Dataclass for RecursiveShapesInputOutputNested1 structure." + + foo: str | None = ... + nested: RecursiveShapesInputOutputNested2 | None = ... + +class RecursiveShapesInputOutputNested1Dict(TypedDict, total=False): + "Dictionary form of `RecursiveShapesInputOutputNested1`." + + foo: str | None + nested: ( + RecursiveShapesInputOutputNested2 | RecursiveShapesInputOutputNested2Dict | None + ) + +@dataclass(kw_only=True) +class RecursiveShapesInputOutputNested2(_SerdeShape): + "Dataclass for RecursiveShapesInputOutputNested2 structure." + + bar: str | None = ... + recursive_member: RecursiveShapesInputOutputNested1 | None = ... + +class RecursiveShapesInputOutputNested2Dict(TypedDict, total=False): + "Dictionary form of `RecursiveShapesInputOutputNested2`." + + bar: str | None + recursive_member: ( + RecursiveShapesInputOutputNested1 | RecursiveShapesInputOutputNested1Dict | None + ) + +@dataclass(kw_only=True) +class ResponseCodeRequiredOutput(_SerdeShape): + "Dataclass for ResponseCodeRequiredOutput structure." + + response_code: int + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass +class SimpleUnionInt(_SerdeShape): + value: int + +@dataclass +class SimpleUnionString(_SerdeShape): + value: str + +@dataclass +class SimpleUnionUnknown(_SerdeShape): + """ + Represents an unknown variant. + + If you receive this value, you will need to update your library to + receive the parsed value. + + This value may not be deliberately sent. + """ + + tag: str + +SimpleUnion = SimpleUnionInt | SimpleUnionString | SimpleUnionUnknown + +class _SimpleUnionDeserializer: + def deserialize(self, deserializer: ShapeDeserializer) -> SimpleUnion: ... + +class SimpleUnionIntDict(TypedDict): + int_: int + +class SimpleUnionStringDict(TypedDict): + string: str + +SimpleUnionDict = SimpleUnionIntDict | SimpleUnionStringDict +"Dictionary form of `SimpleUnion`, setting exactly one variant." + +class StringEnum(UnknownEnumMixin, StrEnum): + V = "enumvalue" + +@dataclass(kw_only=True) +class StructureListMember(_SerdeShape): + "Dataclass for StructureListMember structure." + + a: str | None = ... + b: str | None = ... + +class StructureListMemberDict(TypedDict, total=False): + "Dictionary form of `StructureListMember`." + + a: str | None + b: str | None + +@dataclass(kw_only=True) +class TestConfig(_SerdeShape): + "Dataclass for TestConfig structure." + + timeout: int | None = ... + +class TestConfigDict(TypedDict, total=False): + "Dictionary form of `TestConfig`." + + timeout: int | None + +class TestEnum(UnknownEnumMixin, StrEnum): + FOO = "FOO" + BAR = "BAR" + BAZ = "BAZ" + +class TestIntEnum(UnknownEnumMixin, IntEnum): + ONE = 1 + TWO = 2 + +@dataclass(kw_only=True) +class TopLevel(_SerdeShape): + "Dataclass for TopLevel structure." + + dialog: Dialog + dialog_list: list[Dialog] | None = ... + dialog_map: dict[str, Dialog] | None = ... + +class TopLevelDict(TypedDict, total=False): + "Dictionary form of `TopLevel`." + + dialog: Required[Dialog | DialogDict] + dialog_list: Sequence[Dialog | DialogDict] | None + dialog_map: Mapping[str, Dialog | DialogDict] | None + +@dataclass +class UnionPayloadGreeting(_SerdeShape): + value: str + +@dataclass +class UnionPayloadUnknown(_SerdeShape): + """ + Represents an unknown variant. + + If you receive this value, you will need to update your library to + receive the parsed value. + + This value may not be deliberately sent. + """ + + tag: str + +UnionPayload = UnionPayloadGreeting | UnionPayloadUnknown + +class _UnionPayloadDeserializer: + def deserialize(self, deserializer: ShapeDeserializer) -> UnionPayload: ... + +class UnionPayloadGreetingDict(TypedDict): + greeting: str + +UnionPayloadDict = UnionPayloadGreetingDict +"Dictionary form of `UnionPayload`, setting exactly one variant." + +@dataclass +class UnionWithJsonNameFoo(_SerdeShape): + value: str + +@dataclass +class UnionWithJsonNameBar(_SerdeShape): + value: str + +@dataclass +class UnionWithJsonNameBaz(_SerdeShape): + value: str + +@dataclass +class UnionWithJsonNameUnknown(_SerdeShape): + """ + Represents an unknown variant. + + If you receive this value, you will need to update your library to + receive the parsed value. + + This value may not be deliberately sent. + """ + + tag: str + +UnionWithJsonName = ( + UnionWithJsonNameFoo + | UnionWithJsonNameBar + | UnionWithJsonNameBaz + | UnionWithJsonNameUnknown +) + +class _UnionWithJsonNameDeserializer: + def deserialize(self, deserializer: ShapeDeserializer) -> UnionWithJsonName: ... + +class UnionWithJsonNameFooDict(TypedDict): + foo: str + +class UnionWithJsonNameBarDict(TypedDict): + bar: str + +class UnionWithJsonNameBazDict(TypedDict): + baz: str + +UnionWithJsonNameDict = ( + UnionWithJsonNameFooDict | UnionWithJsonNameBarDict | UnionWithJsonNameBazDict +) +"Dictionary form of `UnionWithJsonName`, setting exactly one variant." + +@dataclass(kw_only=True) +class RenamedGreeting(_SerdeShape): + "Dataclass for GreetingStruct structure." + + salutation: str | None = ... + +class RenamedGreetingDict(TypedDict, total=False): + "Dictionary form of `RenamedGreeting`." + + salutation: str | None + +class FooEnum(UnknownEnumMixin, StrEnum): + FOO = "Foo" + BAZ = "Baz" + BAR = "Bar" + ONE = "1" + ZERO = "0" + +@dataclass(kw_only=True) +class GreetingStruct(_SerdeShape): + "Dataclass for GreetingStruct structure." + + hi: str | None = ... + +class GreetingStructDict(TypedDict, total=False): + "Dictionary form of `GreetingStruct`." + + hi: str | None + +class IntegerEnum(UnknownEnumMixin, IntEnum): + A = 1 + B = 2 + C = 3 + +@dataclass(kw_only=True) +class AllQueryStringTypesOutput(_SerdeShape): + "Dataclass for AllQueryStringTypesOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class ConstantAndVariableQueryStringOutput(_SerdeShape): + "Dataclass for ConstantAndVariableQueryStringOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class ConstantQueryStringOutput(_SerdeShape): + "Dataclass for ConstantQueryStringOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class DatetimeOffsetsInput(_SerdeShape): + "Dataclass for DatetimeOffsetsInput structure." + +class DatetimeOffsetsInputDict(TypedDict, total=False): + "Dictionary form of `DatetimeOffsetsInput`." + +@dataclass(kw_only=True) +class DocumentTypeInput(_SerdeShape): + "Dataclass for DocumentTypeInput structure." + + string_value: str | None = ... + document_value: Document | None = ... + +class DocumentTypeInputDict(TypedDict, total=False): + "Dictionary form of `DocumentTypeInput`." + + string_value: str | None + document_value: Document | None + +@dataclass(kw_only=True) +class DocumentTypeOutput(_SerdeShape): + "Dataclass for DocumentTypeOutput structure." + + string_value: str | None = ... + document_value: Document | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class DocumentTypeAsMapValueInput(_SerdeShape): + "Dataclass for DocumentTypeAsMapValueInput structure." + + doc_valued_map: dict[str, Document] | None = ... + +class DocumentTypeAsMapValueInputDict(TypedDict, total=False): + "Dictionary form of `DocumentTypeAsMapValueInput`." + + doc_valued_map: Mapping[str, Document] | None + +@dataclass(kw_only=True) +class DocumentTypeAsMapValueOutput(_SerdeShape): + "Dataclass for DocumentTypeAsMapValueOutput structure." + + doc_valued_map: dict[str, Document] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class DocumentTypeAsPayloadInput(_SerdeShape): + "Dataclass for DocumentTypeAsPayloadInput structure." + + document_value: Document | None = ... + +class DocumentTypeAsPayloadInputDict(TypedDict, total=False): + "Dictionary form of `DocumentTypeAsPayloadInput`." + + document_value: Document | None + +@dataclass(kw_only=True) +class DocumentTypeAsPayloadOutput(_SerdeShape): + "Dataclass for DocumentTypeAsPayloadOutput structure." + + document_value: Document | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class EndpointOperationInput(_SerdeShape): + "Dataclass for EndpointOperationInput structure." + +class EndpointOperationInputDict(TypedDict, total=False): + "Dictionary form of `EndpointOperationInput`." + +@dataclass(kw_only=True) +class EndpointOperationOutput(_SerdeShape): + "Dataclass for EndpointOperationOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class EndpointWithHostLabelOperationInput(_SerdeShape): + "Dataclass for EndpointWithHostLabelOperationInput structure." + + label: str | None = ... + +class EndpointWithHostLabelOperationInputDict(TypedDict, total=False): + "Dictionary form of `EndpointWithHostLabelOperationInput`." + + label: Required[str] + +@dataclass(kw_only=True) +class EndpointWithHostLabelOperationOutput(_SerdeShape): + "Dataclass for EndpointWithHostLabelOperationOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class FractionalSecondsInput(_SerdeShape): + "Dataclass for FractionalSecondsInput structure." + +class FractionalSecondsInputDict(TypedDict, total=False): + "Dictionary form of `FractionalSecondsInput`." + +@dataclass(kw_only=True) +class GreetingWithErrorsInput(_SerdeShape): + "Dataclass for GreetingWithErrorsInput structure." + +class GreetingWithErrorsInputDict(TypedDict, total=False): + "Dictionary form of `GreetingWithErrorsInput`." + +@dataclass(kw_only=True) +class HostWithPathOperationInput(_SerdeShape): + "Dataclass for HostWithPathOperationInput structure." + +class HostWithPathOperationInputDict(TypedDict, total=False): + "Dictionary form of `HostWithPathOperationInput`." + +@dataclass(kw_only=True) +class HostWithPathOperationOutput(_SerdeShape): + "Dataclass for HostWithPathOperationOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpChecksumRequiredInput(_SerdeShape): + "Dataclass for HttpChecksumRequiredInput structure." + + foo: str | None = ... + +class HttpChecksumRequiredInputDict(TypedDict, total=False): + "Dictionary form of `HttpChecksumRequiredInput`." + + foo: str | None + +@dataclass(kw_only=True) +class HttpChecksumRequiredOutput(_SerdeShape): + "Dataclass for HttpChecksumRequiredOutput structure." + + foo: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpEnumPayloadInput(_SerdeShape): + "Dataclass for HttpEnumPayloadInput structure." + + payload: str | None = ... + +class HttpEnumPayloadInputDict(TypedDict, total=False): + "Dictionary form of `HttpEnumPayloadInput`." + + payload: str | None + +@dataclass(kw_only=True) +class HttpEnumPayloadOutput(_SerdeShape): + "Dataclass for HttpEnumPayloadOutput structure." + + payload: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpPayloadTraitsInput(_SerdeShape): + "Dataclass for HttpPayloadTraitsInput structure." + + foo: str | None = ... + blob: bytes | None = ... + +class HttpPayloadTraitsInputDict(TypedDict, total=False): + "Dictionary form of `HttpPayloadTraitsInput`." + + foo: str | None + blob: bytes | None + +@dataclass(kw_only=True) +class HttpPayloadTraitsOutput(_SerdeShape): + "Dataclass for HttpPayloadTraitsOutput structure." + + foo: str | None = ... + blob: bytes | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpPayloadTraitsWithMediaTypeInput(_SerdeShape): + "Dataclass for HttpPayloadTraitsWithMediaTypeInput structure." + + foo: str | None = ... + blob: bytes | None = ... + +class HttpPayloadTraitsWithMediaTypeInputDict(TypedDict, total=False): + "Dictionary form of `HttpPayloadTraitsWithMediaTypeInput`." + + foo: str | None + blob: bytes | None + +@dataclass(kw_only=True) +class HttpPayloadTraitsWithMediaTypeOutput(_SerdeShape): + "Dataclass for HttpPayloadTraitsWithMediaTypeOutput structure." + + foo: str | None = ... + blob: bytes | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpPayloadWithStructureInput(_SerdeShape): + "Dataclass for HttpPayloadWithStructureInput structure." + + nested: NestedPayload | None = ... + +class HttpPayloadWithStructureInputDict(TypedDict, total=False): + "Dictionary form of `HttpPayloadWithStructureInput`." + + nested: NestedPayload | NestedPayloadDict | None + +@dataclass(kw_only=True) +class HttpPayloadWithStructureOutput(_SerdeShape): + "Dataclass for HttpPayloadWithStructureOutput structure." + + nested: NestedPayload | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpPayloadWithUnionInput(_SerdeShape): + "Dataclass for HttpPayloadWithUnionInput structure." + + nested: UnionPayload | None = ... + +class HttpPayloadWithUnionInputDict(TypedDict, total=False): + "Dictionary form of `HttpPayloadWithUnionInput`." + + nested: UnionPayload | UnionPayloadDict | None + +@dataclass(kw_only=True) +class HttpPayloadWithUnionOutput(_SerdeShape): + "Dataclass for HttpPayloadWithUnionOutput structure." + + nested: UnionPayload | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpQueryParamsOnlyOperationInput(_SerdeShape): + "Dataclass for HttpQueryParamsOnlyOperationInput structure." + + query_map: dict[str, str] | None = ... + +class HttpQueryParamsOnlyOperationInputDict(TypedDict, total=False): + "Dictionary form of `HttpQueryParamsOnlyOperationInput`." + + query_map: Mapping[str, str] | None + +@dataclass(kw_only=True) +class HttpQueryParamsOnlyOperationOutput(_SerdeShape): + "Dataclass for HttpQueryParamsOnlyOperationOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpRequestWithFloatLabelsOutput(_SerdeShape): + "Dataclass for HttpRequestWithFloatLabelsOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpRequestWithGreedyLabelInPathOutput(_SerdeShape): + "Dataclass for HttpRequestWithGreedyLabelInPathOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpRequestWithLabelsOutput(_SerdeShape): + "Dataclass for HttpRequestWithLabelsOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpRequestWithLabelsAndTimestampFormatOutput(_SerdeShape): + "Dataclass for HttpRequestWithLabelsAndTimestampFormatOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpRequestWithRegexLiteralOutput(_SerdeShape): + "Dataclass for HttpRequestWithRegexLiteralOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class HttpResponseCodeInput(_SerdeShape): + "Dataclass for HttpResponseCodeInput structure." + +class HttpResponseCodeInputDict(TypedDict, total=False): + "Dictionary form of `HttpResponseCodeInput`." + +@dataclass(kw_only=True) +class HttpStringPayloadInput(_SerdeShape): + "Dataclass for HttpStringPayloadInput structure." + + payload: str | None = ... + +class HttpStringPayloadInputDict(TypedDict, total=False): + "Dictionary form of `HttpStringPayloadInput`." + + payload: str | None + +@dataclass(kw_only=True) +class HttpStringPayloadOutput(_SerdeShape): + "Dataclass for HttpStringPayloadOutput structure." + + payload: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class IgnoreQueryParamsInResponseInput(_SerdeShape): + "Dataclass for IgnoreQueryParamsInResponseInput structure." + +class IgnoreQueryParamsInResponseInputDict(TypedDict, total=False): + "Dictionary form of `IgnoreQueryParamsInResponseInput`." + +@dataclass(kw_only=True) +class InputAndOutputWithHeadersInput(_SerdeShape): + "Dataclass for InputAndOutputWithHeadersInput structure." + + header_string: str | None = ... + header_byte: int | None = ... + header_short: int | None = ... + header_integer: int | None = ... + header_long: int | None = ... + header_float: float | None = ... + header_double: float | None = ... + header_true_bool: bool | None = ... + header_false_bool: bool | None = ... + header_string_list: list[str] | None = ... + header_string_set: list[str] | None = ... + header_integer_list: list[int] | None = ... + header_boolean_list: list[bool] | None = ... + header_timestamp_list: list[datetime] | None = ... + header_enum: str | None = ... + header_enum_list: list[str] | None = ... + header_integer_enum: int | None = ... + header_integer_enum_list: list[int] | None = ... + +class InputAndOutputWithHeadersInputDict(TypedDict, total=False): + "Dictionary form of `InputAndOutputWithHeadersInput`." + + header_string: str | None + header_byte: int | None + header_short: int | None + header_integer: int | None + header_long: int | None + header_float: float | None + header_double: float | None + header_true_bool: bool | None + header_false_bool: bool | None + header_string_list: Sequence[str] | None + header_string_set: Sequence[str] | None + header_integer_list: Sequence[int] | None + header_boolean_list: Sequence[bool] | None + header_timestamp_list: Sequence[datetime] | None + header_enum: str | None + header_enum_list: Sequence[str] | None + header_integer_enum: int | None + header_integer_enum_list: Sequence[int] | None + +@dataclass(kw_only=True) +class InputAndOutputWithHeadersOutput(_SerdeShape): + "Dataclass for InputAndOutputWithHeadersOutput structure." + + header_string: str | None = ... + header_byte: int | None = ... + header_short: int | None = ... + header_integer: int | None = ... + header_long: int | None = ... + header_float: float | None = ... + header_double: float | None = ... + header_true_bool: bool | None = ... + header_false_bool: bool | None = ... + header_string_list: list[str] | None = ... + header_string_set: list[str] | None = ... + header_integer_list: list[int] | None = ... + header_boolean_list: list[bool] | None = ... + header_timestamp_list: list[datetime] | None = ... + header_enum: str | None = ... + header_enum_list: list[str] | None = ... + header_integer_enum: int | None = ... + header_integer_enum_list: list[int] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class JsonBlobsInput(_SerdeShape): + "Dataclass for JsonBlobsInput structure." + + data: bytes | None = ... + +class JsonBlobsInputDict(TypedDict, total=False): + "Dictionary form of `JsonBlobsInput`." + + data: bytes | None + +@dataclass(kw_only=True) +class JsonBlobsOutput(_SerdeShape): + "Dataclass for JsonBlobsOutput structure." + + data: bytes | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class JsonEnumsInput(_SerdeShape): + "Dataclass for JsonEnumsInput structure." + + foo_enum1: str | None = ... + foo_enum2: str | None = ... + foo_enum3: str | None = ... + foo_enum_list: list[str] | None = ... + foo_enum_set: list[str] | None = ... + foo_enum_map: dict[str, str] | None = ... + +class JsonEnumsInputDict(TypedDict, total=False): + "Dictionary form of `JsonEnumsInput`." + + foo_enum1: str | None + foo_enum2: str | None + foo_enum3: str | None + foo_enum_list: Sequence[str] | None + foo_enum_set: Sequence[str] | None + foo_enum_map: Mapping[str, str] | None + +@dataclass(kw_only=True) +class JsonEnumsOutput(_SerdeShape): + "Dataclass for JsonEnumsOutput structure." + + foo_enum1: str | None = ... + foo_enum2: str | None = ... + foo_enum3: str | None = ... + foo_enum_list: list[str] | None = ... + foo_enum_set: list[str] | None = ... + foo_enum_map: dict[str, str] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class JsonIntEnumsInput(_SerdeShape): + "Dataclass for JsonIntEnumsInput structure." + + integer_enum1: int | None = ... + integer_enum2: int | None = ... + integer_enum3: int | None = ... + integer_enum_list: list[int] | None = ... + integer_enum_set: list[int] | None = ... + integer_enum_map: dict[str, int] | None = ... + +class JsonIntEnumsInputDict(TypedDict, total=False): + "Dictionary form of `JsonIntEnumsInput`." + + integer_enum1: int | None + integer_enum2: int | None + integer_enum3: int | None + integer_enum_list: Sequence[int] | None + integer_enum_set: Sequence[int] | None + integer_enum_map: Mapping[str, int] | None + +@dataclass(kw_only=True) +class JsonIntEnumsOutput(_SerdeShape): + "Dataclass for JsonIntEnumsOutput structure." + + integer_enum1: int | None = ... + integer_enum2: int | None = ... + integer_enum3: int | None = ... + integer_enum_list: list[int] | None = ... + integer_enum_set: list[int] | None = ... + integer_enum_map: dict[str, int] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class JsonListsInput(_SerdeShape): + "Dataclass for JsonListsInput structure." + + string_list: list[str] | None = ... + string_set: list[str] | None = ... + integer_list: list[int] | None = ... + boolean_list: list[bool] | None = ... + timestamp_list: list[datetime] | None = ... + enum_list: list[str] | None = ... + int_enum_list: list[int] | None = ... + nested_string_list: list[list[str]] | None = ... + structure_list: list[StructureListMember] | None = ... + +class JsonListsInputDict(TypedDict, total=False): + "Dictionary form of `JsonListsInput`." + + string_list: Sequence[str] | None + string_set: Sequence[str] | None + integer_list: Sequence[int] | None + boolean_list: Sequence[bool] | None + timestamp_list: Sequence[datetime] | None + enum_list: Sequence[str] | None + int_enum_list: Sequence[int] | None + nested_string_list: Sequence[Sequence[str]] | None + structure_list: Sequence[StructureListMember | StructureListMemberDict] | None + +@dataclass(kw_only=True) +class JsonListsOutput(_SerdeShape): + "Dataclass for JsonListsOutput structure." + + string_list: list[str] | None = ... + string_set: list[str] | None = ... + integer_list: list[int] | None = ... + boolean_list: list[bool] | None = ... + timestamp_list: list[datetime] | None = ... + enum_list: list[str] | None = ... + int_enum_list: list[int] | None = ... + nested_string_list: list[list[str]] | None = ... + structure_list: list[StructureListMember] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class JsonMapsInput(_SerdeShape): + "Dataclass for JsonMapsInput structure." + + dense_struct_map: dict[str, GreetingStruct] | None = ... + dense_number_map: dict[str, int] | None = ... + dense_boolean_map: dict[str, bool] | None = ... + dense_string_map: dict[str, str] | None = ... + dense_set_map: dict[str, list[str]] | None = ... + +class JsonMapsInputDict(TypedDict, total=False): + "Dictionary form of `JsonMapsInput`." + + dense_struct_map: Mapping[str, GreetingStruct | GreetingStructDict] | None + dense_number_map: Mapping[str, int] | None + dense_boolean_map: Mapping[str, bool] | None + dense_string_map: Mapping[str, str] | None + dense_set_map: Mapping[str, Sequence[str]] | None + +@dataclass(kw_only=True) +class JsonMapsOutput(_SerdeShape): + "Dataclass for JsonMapsOutput structure." + + dense_struct_map: dict[str, GreetingStruct] | None = ... + dense_number_map: dict[str, int] | None = ... + dense_boolean_map: dict[str, bool] | None = ... + dense_string_map: dict[str, str] | None = ... + dense_set_map: dict[str, list[str]] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class JsonTimestampsInput(_SerdeShape): + "Dataclass for JsonTimestampsInput structure." + + normal: datetime | None = ... + date_time: datetime | None = ... + date_time_on_target: datetime | None = ... + epoch_seconds: datetime | None = ... + epoch_seconds_on_target: datetime | None = ... + http_date: datetime | None = ... + http_date_on_target: datetime | None = ... + +class JsonTimestampsInputDict(TypedDict, total=False): + "Dictionary form of `JsonTimestampsInput`." + + normal: datetime | None + date_time: datetime | None + date_time_on_target: datetime | None + epoch_seconds: datetime | None + epoch_seconds_on_target: datetime | None + http_date: datetime | None + http_date_on_target: datetime | None + +@dataclass(kw_only=True) +class JsonTimestampsOutput(_SerdeShape): + "Dataclass for JsonTimestampsOutput structure." + + normal: datetime | None = ... + date_time: datetime | None = ... + date_time_on_target: datetime | None = ... + epoch_seconds: datetime | None = ... + epoch_seconds_on_target: datetime | None = ... + http_date: datetime | None = ... + http_date_on_target: datetime | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class JsonUnionsInput(_SerdeShape): + "A shared structure that contains a single union member." + + contents: MyUnion | None = ... + +class JsonUnionsInputDict(TypedDict, total=False): + "Dictionary form of `JsonUnionsInput`." + + contents: MyUnion | MyUnionDict | None + +@dataclass(kw_only=True) +class JsonUnionsOutput(_SerdeShape): + "A shared structure that contains a single union member." + + contents: MyUnion | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedAcceptWithBodyInput(_SerdeShape): + "Dataclass for MalformedAcceptWithBodyInput structure." + +class MalformedAcceptWithBodyInputDict(TypedDict, total=False): + "Dictionary form of `MalformedAcceptWithBodyInput`." + +@dataclass(kw_only=True) +class MalformedAcceptWithBodyOutput(_SerdeShape): + "Dataclass for MalformedAcceptWithBodyOutput structure." + + hi: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedAcceptWithGenericStringInput(_SerdeShape): + "Dataclass for MalformedAcceptWithGenericStringInput structure." + +class MalformedAcceptWithGenericStringInputDict(TypedDict, total=False): + "Dictionary form of `MalformedAcceptWithGenericStringInput`." + +@dataclass(kw_only=True) +class MalformedAcceptWithPayloadInput(_SerdeShape): + "Dataclass for MalformedAcceptWithPayloadInput structure." + +class MalformedAcceptWithPayloadInputDict(TypedDict, total=False): + "Dictionary form of `MalformedAcceptWithPayloadInput`." + +@dataclass(kw_only=True) +class MalformedBlobOutput(_SerdeShape): + "Dataclass for MalformedBlobOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedBooleanOutput(_SerdeShape): + "Dataclass for MalformedBooleanOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedByteOutput(_SerdeShape): + "Dataclass for MalformedByteOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedContentTypeWithBodyInput(_SerdeShape): + "Dataclass for MalformedContentTypeWithBodyInput structure." + + hi: str | None = ... + +class MalformedContentTypeWithBodyInputDict(TypedDict, total=False): + "Dictionary form of `MalformedContentTypeWithBodyInput`." + + hi: str | None + +@dataclass(kw_only=True) +class MalformedContentTypeWithBodyOutput(_SerdeShape): + "Dataclass for MalformedContentTypeWithBodyOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedContentTypeWithGenericStringOutput(_SerdeShape): + "Dataclass for MalformedContentTypeWithGenericStringOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedContentTypeWithPayloadOutput(_SerdeShape): + "Dataclass for MalformedContentTypeWithPayloadOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedContentTypeWithoutBodyInput(_SerdeShape): + "Dataclass for MalformedContentTypeWithoutBodyInput structure." + +class MalformedContentTypeWithoutBodyInputDict(TypedDict, total=False): + "Dictionary form of `MalformedContentTypeWithoutBodyInput`." + +@dataclass(kw_only=True) +class MalformedContentTypeWithoutBodyOutput(_SerdeShape): + "Dataclass for MalformedContentTypeWithoutBodyOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedContentTypeWithoutBodyEmptyInputOutput(_SerdeShape): + "Dataclass for MalformedContentTypeWithoutBodyEmptyInputOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedDoubleOutput(_SerdeShape): + "Dataclass for MalformedDoubleOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedFloatOutput(_SerdeShape): + "Dataclass for MalformedFloatOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedIntegerOutput(_SerdeShape): + "Dataclass for MalformedIntegerOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedListOutput(_SerdeShape): + "Dataclass for MalformedListOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedLongOutput(_SerdeShape): + "Dataclass for MalformedLongOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedMapOutput(_SerdeShape): + "Dataclass for MalformedMapOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedRequestBodyOutput(_SerdeShape): + "Dataclass for MalformedRequestBodyOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedShortOutput(_SerdeShape): + "Dataclass for MalformedShortOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedStringOutput(_SerdeShape): + "Dataclass for MalformedStringOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampBodyDateTimeOutput(_SerdeShape): + "Dataclass for MalformedTimestampBodyDateTimeOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampBodyDefaultOutput(_SerdeShape): + "Dataclass for MalformedTimestampBodyDefaultOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampBodyHttpDateOutput(_SerdeShape): + "Dataclass for MalformedTimestampBodyHttpDateOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampHeaderDateTimeOutput(_SerdeShape): + "Dataclass for MalformedTimestampHeaderDateTimeOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampHeaderDefaultOutput(_SerdeShape): + "Dataclass for MalformedTimestampHeaderDefaultOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampHeaderEpochOutput(_SerdeShape): + "Dataclass for MalformedTimestampHeaderEpochOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampPathDefaultOutput(_SerdeShape): + "Dataclass for MalformedTimestampPathDefaultOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampPathEpochOutput(_SerdeShape): + "Dataclass for MalformedTimestampPathEpochOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampPathHttpDateOutput(_SerdeShape): + "Dataclass for MalformedTimestampPathHttpDateOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampQueryDefaultOutput(_SerdeShape): + "Dataclass for MalformedTimestampQueryDefaultOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampQueryEpochOutput(_SerdeShape): + "Dataclass for MalformedTimestampQueryEpochOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedTimestampQueryHttpDateOutput(_SerdeShape): + "Dataclass for MalformedTimestampQueryHttpDateOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class MalformedUnionOutput(_SerdeShape): + "Dataclass for MalformedUnionOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class NoInputAndNoOutputInput(_SerdeShape): + "Dataclass for NoInputAndNoOutputInput structure." + +class NoInputAndNoOutputInputDict(TypedDict, total=False): + "Dictionary form of `NoInputAndNoOutputInput`." + +@dataclass(kw_only=True) +class NoInputAndNoOutputOutput(_SerdeShape): + "Dataclass for NoInputAndNoOutputOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class NoInputAndOutputInput(_SerdeShape): + "Dataclass for NoInputAndOutputInput structure." + +class NoInputAndOutputInputDict(TypedDict, total=False): + "Dictionary form of `NoInputAndOutputInput`." + +@dataclass(kw_only=True) +class NullAndEmptyHeadersClientInput(_SerdeShape): + "Dataclass for NullAndEmptyHeadersClientInput structure." + + a: str | None = ... + b: str | None = ... + c: list[str] | None = ... + +class NullAndEmptyHeadersClientInputDict(TypedDict, total=False): + "Dictionary form of `NullAndEmptyHeadersClientInput`." + + a: str | None + b: str | None + c: Sequence[str] | None + +@dataclass(kw_only=True) +class NullAndEmptyHeadersClientOutput(_SerdeShape): + "Dataclass for NullAndEmptyHeadersClientOutput structure." + + a: str | None = ... + b: str | None = ... + c: list[str] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class NullAndEmptyHeadersServerInput(_SerdeShape): + "Dataclass for NullAndEmptyHeadersServerInput structure." + + a: str | None = ... + b: str | None = ... + c: list[str] | None = ... + +class NullAndEmptyHeadersServerInputDict(TypedDict, total=False): + "Dictionary form of `NullAndEmptyHeadersServerInput`." + + a: str | None + b: str | None + c: Sequence[str] | None + +@dataclass(kw_only=True) +class NullAndEmptyHeadersServerOutput(_SerdeShape): + "Dataclass for NullAndEmptyHeadersServerOutput structure." + + a: str | None = ... + b: str | None = ... + c: list[str] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class OmitsNullSerializesEmptyStringOutput(_SerdeShape): + "Dataclass for OmitsNullSerializesEmptyStringOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class OmitsSerializingEmptyListsOutput(_SerdeShape): + "Dataclass for OmitsSerializingEmptyListsOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class PutWithContentEncodingOutput(_SerdeShape): + "Dataclass for PutWithContentEncodingOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class QueryIdempotencyTokenAutoFillOutput(_SerdeShape): + "Dataclass for QueryIdempotencyTokenAutoFillOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class QueryParamsAsStringListMapOutput(_SerdeShape): + "Dataclass for QueryParamsAsStringListMapOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class QueryPrecedenceOutput(_SerdeShape): + "Dataclass for QueryPrecedenceOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class RecursiveShapesInput(_SerdeShape): + "Dataclass for RecursiveShapesInput structure." + + nested: RecursiveShapesInputOutputNested1 | None = ... + +class RecursiveShapesInputDict(TypedDict, total=False): + "Dictionary form of `RecursiveShapesInput`." + + nested: ( + RecursiveShapesInputOutputNested1 | RecursiveShapesInputOutputNested1Dict | None + ) + +@dataclass(kw_only=True) +class RecursiveShapesOutput(_SerdeShape): + "Dataclass for RecursiveShapesOutput structure." + + nested: RecursiveShapesInputOutputNested1 | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class ResponseCodeHttpFallbackInput(_SerdeShape): + "Dataclass for ResponseCodeHttpFallbackInput structure." + +class ResponseCodeHttpFallbackInputDict(TypedDict, total=False): + "Dictionary form of `ResponseCodeHttpFallbackInput`." + +@dataclass(kw_only=True) +class ResponseCodeHttpFallbackOutput(_SerdeShape): + "Dataclass for ResponseCodeHttpFallbackOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class ResponseCodeRequiredInput(_SerdeShape): + "Dataclass for ResponseCodeRequiredInput structure." + +class ResponseCodeRequiredInputDict(TypedDict, total=False): + "Dictionary form of `ResponseCodeRequiredInput`." + +@dataclass(kw_only=True) +class SimpleScalarPropertiesInput(_SerdeShape): + "Dataclass for SimpleScalarPropertiesInput structure." + + foo: str | None = ... + string_value: str | None = ... + true_boolean_value: bool | None = ... + false_boolean_value: bool | None = ... + byte_value: int | None = ... + short_value: int | None = ... + integer_value: int | None = ... + long_value: int | None = ... + float_value: float | None = ... + double_value: float | None = ... + +class SimpleScalarPropertiesInputDict(TypedDict, total=False): + "Dictionary form of `SimpleScalarPropertiesInput`." + + foo: str | None + string_value: str | None + true_boolean_value: bool | None + false_boolean_value: bool | None + byte_value: int | None + short_value: int | None + integer_value: int | None + long_value: int | None + float_value: float | None + double_value: float | None + +@dataclass(kw_only=True) +class SimpleScalarPropertiesOutput(_SerdeShape): + "Dataclass for SimpleScalarPropertiesOutput structure." + + foo: str | None = ... + string_value: str | None = ... + true_boolean_value: bool | None = ... + false_boolean_value: bool | None = ... + byte_value: int | None = ... + short_value: int | None = ... + integer_value: int | None = ... + long_value: int | None = ... + float_value: float | None = ... + double_value: float | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class SparseJsonListsInput(_SerdeShape): + "Dataclass for SparseJsonListsInput structure." + + sparse_string_list: list[str | None] | None = ... + sparse_short_list: list[int | None] | None = ... + +class SparseJsonListsInputDict(TypedDict, total=False): + "Dictionary form of `SparseJsonListsInput`." + + sparse_string_list: Sequence[str | None] | None + sparse_short_list: Sequence[int | None] | None + +@dataclass(kw_only=True) +class SparseJsonListsOutput(_SerdeShape): + "Dataclass for SparseJsonListsOutput structure." + + sparse_string_list: list[str | None] | None = ... + sparse_short_list: list[int | None] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class SparseJsonMapsInput(_SerdeShape): + "Dataclass for SparseJsonMapsInput structure." + + sparse_struct_map: dict[str, GreetingStruct | None] | None = ... + sparse_number_map: dict[str, int | None] | None = ... + sparse_boolean_map: dict[str, bool | None] | None = ... + sparse_string_map: dict[str, str | None] | None = ... + sparse_set_map: dict[str, list[str] | None] | None = ... + +class SparseJsonMapsInputDict(TypedDict, total=False): + "Dictionary form of `SparseJsonMapsInput`." + + sparse_struct_map: Mapping[str, GreetingStruct | GreetingStructDict | None] | None + sparse_number_map: Mapping[str, int | None] | None + sparse_boolean_map: Mapping[str, bool | None] | None + sparse_string_map: Mapping[str, str | None] | None + sparse_set_map: Mapping[str, Sequence[str] | None] | None + +@dataclass(kw_only=True) +class SparseJsonMapsOutput(_SerdeShape): + "Dataclass for SparseJsonMapsOutput structure." + + sparse_struct_map: dict[str, GreetingStruct | None] | None = ... + sparse_number_map: dict[str, int | None] | None = ... + sparse_boolean_map: dict[str, bool | None] | None = ... + sparse_string_map: dict[str, str | None] | None = ... + sparse_set_map: dict[str, list[str] | None] | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TestBodyStructureInput(_SerdeShape): + "Dataclass for TestBodyStructureInput structure." + + test_id: str | None = ... + test_config: TestConfig | None = ... + +class TestBodyStructureInputDict(TypedDict, total=False): + "Dictionary form of `TestBodyStructureInput`." + + test_id: str | None + test_config: TestConfig | TestConfigDict | None + +@dataclass(kw_only=True) +class TestBodyStructureOutput(_SerdeShape): + "Dataclass for TestBodyStructureOutput structure." + + test_id: str | None = ... + test_config: TestConfig | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TestGetNoInputNoPayloadInput(_SerdeShape): + "Dataclass for TestGetNoInputNoPayloadInput structure." + +class TestGetNoInputNoPayloadInputDict(TypedDict, total=False): + "Dictionary form of `TestGetNoInputNoPayloadInput`." + +@dataclass(kw_only=True) +class TestGetNoInputNoPayloadOutput(_SerdeShape): + "Dataclass for TestGetNoInputNoPayloadOutput structure." + + test_id: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TestGetNoPayloadInput(_SerdeShape): + "Dataclass for TestGetNoPayloadInput structure." + + test_id: str | None = ... + +class TestGetNoPayloadInputDict(TypedDict, total=False): + "Dictionary form of `TestGetNoPayloadInput`." + + test_id: str | None + +@dataclass(kw_only=True) +class TestGetNoPayloadOutput(_SerdeShape): + "Dataclass for TestGetNoPayloadOutput structure." + + test_id: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TestPayloadBlobInput(_SerdeShape): + "Dataclass for TestPayloadBlobInput structure." + + content_type: str | None = ... + data: bytes | None = ... + +class TestPayloadBlobInputDict(TypedDict, total=False): + "Dictionary form of `TestPayloadBlobInput`." + + content_type: str | None + data: bytes | None + +@dataclass(kw_only=True) +class TestPayloadBlobOutput(_SerdeShape): + "Dataclass for TestPayloadBlobOutput structure." + + content_type: str | None = ... + data: bytes | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TestPayloadStructureInput(_SerdeShape): + "Dataclass for TestPayloadStructureInput structure." + + test_id: str | None = ... + payload_config: PayloadConfig | None = ... + +class TestPayloadStructureInputDict(TypedDict, total=False): + "Dictionary form of `TestPayloadStructureInput`." + + test_id: str | None + payload_config: PayloadConfig | PayloadConfigDict | None + +@dataclass(kw_only=True) +class TestPayloadStructureOutput(_SerdeShape): + "Dataclass for TestPayloadStructureOutput structure." + + test_id: str | None = ... + payload_config: PayloadConfig | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TestPostNoInputNoPayloadInput(_SerdeShape): + "Dataclass for TestPostNoInputNoPayloadInput structure." + +class TestPostNoInputNoPayloadInputDict(TypedDict, total=False): + "Dictionary form of `TestPostNoInputNoPayloadInput`." + +@dataclass(kw_only=True) +class TestPostNoInputNoPayloadOutput(_SerdeShape): + "Dataclass for TestPostNoInputNoPayloadOutput structure." + + test_id: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TestPostNoPayloadInput(_SerdeShape): + "Dataclass for TestPostNoPayloadInput structure." + + test_id: str | None = ... + +class TestPostNoPayloadInputDict(TypedDict, total=False): + "Dictionary form of `TestPostNoPayloadInput`." + + test_id: str | None + +@dataclass(kw_only=True) +class TestPostNoPayloadOutput(_SerdeShape): + "Dataclass for TestPostNoPayloadOutput structure." + + test_id: str | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class TimestampFormatHeadersInput(_SerdeShape): + "Dataclass for TimestampFormatHeadersInput structure." + + member_epoch_seconds: datetime | None = ... + member_http_date: datetime | None = ... + member_date_time: datetime | None = ... + default_format: datetime | None = ... + target_epoch_seconds: datetime | None = ... + target_http_date: datetime | None = ... + target_date_time: datetime | None = ... + +class TimestampFormatHeadersInputDict(TypedDict, total=False): + "Dictionary form of `TimestampFormatHeadersInput`." + + member_epoch_seconds: datetime | None + member_http_date: datetime | None + member_date_time: datetime | None + default_format: datetime | None + target_epoch_seconds: datetime | None + target_http_date: datetime | None + target_date_time: datetime | None + +@dataclass(kw_only=True) +class TimestampFormatHeadersOutput(_SerdeShape): + "Dataclass for TimestampFormatHeadersOutput structure." + + member_epoch_seconds: datetime | None = ... + member_http_date: datetime | None = ... + member_date_time: datetime | None = ... + default_format: datetime | None = ... + target_epoch_seconds: datetime | None = ... + target_http_date: datetime | None = ... + target_date_time: datetime | None = ... + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class UnitInputAndOutputInput(_SerdeShape): + "Dataclass for UnitInputAndOutputInput structure." + +class UnitInputAndOutputInputDict(TypedDict, total=False): + "Dictionary form of `UnitInputAndOutputInput`." + +@dataclass(kw_only=True) +class UnitInputAndOutputOutput(_SerdeShape): + "Dataclass for UnitInputAndOutputOutput structure." + + response_metadata: ResponseMetadata = ... + """ + Metadata about the response that produced this output. + + Use this to recover the request identifiers a service's support team + needs in order to investigate a call. Members of the metadata are + individually optional. + """ + +@dataclass(kw_only=True) +class Unit(_SerdeShape): + pass + +class UnitDict(TypedDict, total=False): + "Dictionary form of `Unit`." + +ALL_QUERY_STRING_TYPES: APIOperation[ + AllQueryStringTypesInput, AllQueryStringTypesOutput +] +CONSTANT_AND_VARIABLE_QUERY_STRING: APIOperation[ + ConstantAndVariableQueryStringInput, ConstantAndVariableQueryStringOutput +] +CONSTANT_QUERY_STRING: APIOperation[ConstantQueryStringInput, ConstantQueryStringOutput] +CONTENT_TYPE_PARAMETERS: APIOperation[ + ContentTypeParametersInput, ContentTypeParametersOutput +] +DATETIME_OFFSETS: APIOperation[DatetimeOffsetsInput, DatetimeOffsetsOutput] +DOCUMENT_TYPE: APIOperation[DocumentTypeInput, DocumentTypeOutput] +DOCUMENT_TYPE_AS_MAP_VALUE: APIOperation[ + DocumentTypeAsMapValueInput, DocumentTypeAsMapValueOutput +] +DOCUMENT_TYPE_AS_PAYLOAD: APIOperation[ + DocumentTypeAsPayloadInput, DocumentTypeAsPayloadOutput +] +EMPTY_INPUT_AND_EMPTY_OUTPUT: APIOperation[ + EmptyInputAndEmptyOutputInput, EmptyInputAndEmptyOutputOutput +] +ENDPOINT_OPERATION: APIOperation[EndpointOperationInput, EndpointOperationOutput] +ENDPOINT_WITH_HOST_LABEL_OPERATION: APIOperation[ + EndpointWithHostLabelOperationInput, EndpointWithHostLabelOperationOutput +] +FRACTIONAL_SECONDS: APIOperation[FractionalSecondsInput, FractionalSecondsOutput] +GREETING_WITH_ERRORS: APIOperation[GreetingWithErrorsInput, GreetingWithErrorsOutput] +HOST_WITH_PATH_OPERATION: APIOperation[ + HostWithPathOperationInput, HostWithPathOperationOutput +] +HTTP_CHECKSUM_REQUIRED: APIOperation[ + HttpChecksumRequiredInput, HttpChecksumRequiredOutput +] +HTTP_EMPTY_PREFIX_HEADERS: APIOperation[ + HttpEmptyPrefixHeadersInput, HttpEmptyPrefixHeadersOutput +] +HTTP_ENUM_PAYLOAD: APIOperation[HttpEnumPayloadInput, HttpEnumPayloadOutput] +HTTP_PAYLOAD_TRAITS: APIOperation[HttpPayloadTraitsInput, HttpPayloadTraitsOutput] +HTTP_PAYLOAD_TRAITS_WITH_MEDIA_TYPE: APIOperation[ + HttpPayloadTraitsWithMediaTypeInput, HttpPayloadTraitsWithMediaTypeOutput +] +HTTP_PAYLOAD_WITH_STRUCTURE: APIOperation[ + HttpPayloadWithStructureInput, HttpPayloadWithStructureOutput +] +HTTP_PAYLOAD_WITH_UNION: APIOperation[ + HttpPayloadWithUnionInput, HttpPayloadWithUnionOutput +] +HTTP_PREFIX_HEADERS: APIOperation[HttpPrefixHeadersInput, HttpPrefixHeadersOutput] +HTTP_PREFIX_HEADERS_IN_RESPONSE: APIOperation[ + HttpPrefixHeadersInResponseInput, HttpPrefixHeadersInResponseOutput +] +HTTP_QUERY_PARAMS_ONLY_OPERATION: APIOperation[ + HttpQueryParamsOnlyOperationInput, HttpQueryParamsOnlyOperationOutput +] +HTTP_REQUEST_WITH_FLOAT_LABELS: APIOperation[ + HttpRequestWithFloatLabelsInput, HttpRequestWithFloatLabelsOutput +] +HTTP_REQUEST_WITH_GREEDY_LABEL_IN_PATH: APIOperation[ + HttpRequestWithGreedyLabelInPathInput, HttpRequestWithGreedyLabelInPathOutput +] +HTTP_REQUEST_WITH_LABELS: APIOperation[ + HttpRequestWithLabelsInput, HttpRequestWithLabelsOutput +] +HTTP_REQUEST_WITH_LABELS_AND_TIMESTAMP_FORMAT: APIOperation[ + HttpRequestWithLabelsAndTimestampFormatInput, + HttpRequestWithLabelsAndTimestampFormatOutput, +] +HTTP_REQUEST_WITH_REGEX_LITERAL: APIOperation[ + HttpRequestWithRegexLiteralInput, HttpRequestWithRegexLiteralOutput +] +HTTP_RESPONSE_CODE: APIOperation[HttpResponseCodeInput, HttpResponseCodeOutput] +HTTP_STRING_PAYLOAD: APIOperation[HttpStringPayloadInput, HttpStringPayloadOutput] +IGNORE_QUERY_PARAMS_IN_RESPONSE: APIOperation[ + IgnoreQueryParamsInResponseInput, IgnoreQueryParamsInResponseOutput +] +INPUT_AND_OUTPUT_WITH_HEADERS: APIOperation[ + InputAndOutputWithHeadersInput, InputAndOutputWithHeadersOutput +] +JSON_BLOBS: APIOperation[JsonBlobsInput, JsonBlobsOutput] +JSON_ENUMS: APIOperation[JsonEnumsInput, JsonEnumsOutput] +JSON_INT_ENUMS: APIOperation[JsonIntEnumsInput, JsonIntEnumsOutput] +JSON_LISTS: APIOperation[JsonListsInput, JsonListsOutput] +JSON_MAPS: APIOperation[JsonMapsInput, JsonMapsOutput] +JSON_TIMESTAMPS: APIOperation[JsonTimestampsInput, JsonTimestampsOutput] +JSON_UNIONS: APIOperation[JsonUnionsInput, JsonUnionsOutput] +MALFORMED_ACCEPT_WITH_BODY: APIOperation[ + MalformedAcceptWithBodyInput, MalformedAcceptWithBodyOutput +] +MALFORMED_ACCEPT_WITH_GENERIC_STRING: APIOperation[ + MalformedAcceptWithGenericStringInput, MalformedAcceptWithGenericStringOutput +] +MALFORMED_ACCEPT_WITH_PAYLOAD: APIOperation[ + MalformedAcceptWithPayloadInput, MalformedAcceptWithPayloadOutput +] +MALFORMED_BLOB: APIOperation[MalformedBlobInput, MalformedBlobOutput] +MALFORMED_BOOLEAN: APIOperation[MalformedBooleanInput, MalformedBooleanOutput] +MALFORMED_BYTE: APIOperation[MalformedByteInput, MalformedByteOutput] +MALFORMED_CONTENT_TYPE_WITH_BODY: APIOperation[ + MalformedContentTypeWithBodyInput, MalformedContentTypeWithBodyOutput +] +MALFORMED_CONTENT_TYPE_WITH_GENERIC_STRING: APIOperation[ + MalformedContentTypeWithGenericStringInput, + MalformedContentTypeWithGenericStringOutput, +] +MALFORMED_CONTENT_TYPE_WITH_PAYLOAD: APIOperation[ + MalformedContentTypeWithPayloadInput, MalformedContentTypeWithPayloadOutput +] +MALFORMED_CONTENT_TYPE_WITHOUT_BODY: APIOperation[ + MalformedContentTypeWithoutBodyInput, MalformedContentTypeWithoutBodyOutput +] +MALFORMED_CONTENT_TYPE_WITHOUT_BODY_EMPTY_INPUT: APIOperation[ + MalformedContentTypeWithoutBodyEmptyInputInput, + MalformedContentTypeWithoutBodyEmptyInputOutput, +] +MALFORMED_DOUBLE: APIOperation[MalformedDoubleInput, MalformedDoubleOutput] +MALFORMED_FLOAT: APIOperation[MalformedFloatInput, MalformedFloatOutput] +MALFORMED_INTEGER: APIOperation[MalformedIntegerInput, MalformedIntegerOutput] +MALFORMED_LIST: APIOperation[MalformedListInput, MalformedListOutput] +MALFORMED_LONG: APIOperation[MalformedLongInput, MalformedLongOutput] +MALFORMED_MAP: APIOperation[MalformedMapInput, MalformedMapOutput] +MALFORMED_REQUEST_BODY: APIOperation[ + MalformedRequestBodyInput, MalformedRequestBodyOutput +] +MALFORMED_SHORT: APIOperation[MalformedShortInput, MalformedShortOutput] +MALFORMED_STRING: APIOperation[MalformedStringInput, MalformedStringOutput] +MALFORMED_TIMESTAMP_BODY_DATE_TIME: APIOperation[ + MalformedTimestampBodyDateTimeInput, MalformedTimestampBodyDateTimeOutput +] +MALFORMED_TIMESTAMP_BODY_DEFAULT: APIOperation[ + MalformedTimestampBodyDefaultInput, MalformedTimestampBodyDefaultOutput +] +MALFORMED_TIMESTAMP_BODY_HTTP_DATE: APIOperation[ + MalformedTimestampBodyHttpDateInput, MalformedTimestampBodyHttpDateOutput +] +MALFORMED_TIMESTAMP_HEADER_DATE_TIME: APIOperation[ + MalformedTimestampHeaderDateTimeInput, MalformedTimestampHeaderDateTimeOutput +] +MALFORMED_TIMESTAMP_HEADER_DEFAULT: APIOperation[ + MalformedTimestampHeaderDefaultInput, MalformedTimestampHeaderDefaultOutput +] +MALFORMED_TIMESTAMP_HEADER_EPOCH: APIOperation[ + MalformedTimestampHeaderEpochInput, MalformedTimestampHeaderEpochOutput +] +MALFORMED_TIMESTAMP_PATH_DEFAULT: APIOperation[ + MalformedTimestampPathDefaultInput, MalformedTimestampPathDefaultOutput +] +MALFORMED_TIMESTAMP_PATH_EPOCH: APIOperation[ + MalformedTimestampPathEpochInput, MalformedTimestampPathEpochOutput +] +MALFORMED_TIMESTAMP_PATH_HTTP_DATE: APIOperation[ + MalformedTimestampPathHttpDateInput, MalformedTimestampPathHttpDateOutput +] +MALFORMED_TIMESTAMP_QUERY_DEFAULT: APIOperation[ + MalformedTimestampQueryDefaultInput, MalformedTimestampQueryDefaultOutput +] +MALFORMED_TIMESTAMP_QUERY_EPOCH: APIOperation[ + MalformedTimestampQueryEpochInput, MalformedTimestampQueryEpochOutput +] +MALFORMED_TIMESTAMP_QUERY_HTTP_DATE: APIOperation[ + MalformedTimestampQueryHttpDateInput, MalformedTimestampQueryHttpDateOutput +] +MALFORMED_UNION: APIOperation[MalformedUnionInput, MalformedUnionOutput] +MEDIA_TYPE_HEADER: APIOperation[MediaTypeHeaderInput, MediaTypeHeaderOutput] +NO_INPUT_AND_NO_OUTPUT: APIOperation[NoInputAndNoOutputInput, NoInputAndNoOutputOutput] +NO_INPUT_AND_OUTPUT: APIOperation[NoInputAndOutputInput, NoInputAndOutputOutput] +NULL_AND_EMPTY_HEADERS_CLIENT: APIOperation[ + NullAndEmptyHeadersClientInput, NullAndEmptyHeadersClientOutput +] +NULL_AND_EMPTY_HEADERS_SERVER: APIOperation[ + NullAndEmptyHeadersServerInput, NullAndEmptyHeadersServerOutput +] +OMITS_NULL_SERIALIZES_EMPTY_STRING: APIOperation[ + OmitsNullSerializesEmptyStringInput, OmitsNullSerializesEmptyStringOutput +] +OMITS_SERIALIZING_EMPTY_LISTS: APIOperation[ + OmitsSerializingEmptyListsInput, OmitsSerializingEmptyListsOutput +] +OPERATION_WITH_DEFAULTS: APIOperation[ + OperationWithDefaultsInput, OperationWithDefaultsOutput +] +OPERATION_WITH_NESTED_STRUCTURE: APIOperation[ + OperationWithNestedStructureInput, OperationWithNestedStructureOutput +] +POST_PLAYER_ACTION: APIOperation[PostPlayerActionInput, PostPlayerActionOutput] +POST_UNION_WITH_JSON_NAME: APIOperation[ + PostUnionWithJsonNameInput, PostUnionWithJsonNameOutput +] +PUT_WITH_CONTENT_ENCODING: APIOperation[ + PutWithContentEncodingInput, PutWithContentEncodingOutput +] +QUERY_IDEMPOTENCY_TOKEN_AUTO_FILL: APIOperation[ + QueryIdempotencyTokenAutoFillInput, QueryIdempotencyTokenAutoFillOutput +] +QUERY_PARAMS_AS_STRING_LIST_MAP: APIOperation[ + QueryParamsAsStringListMapInput, QueryParamsAsStringListMapOutput +] +QUERY_PRECEDENCE: APIOperation[QueryPrecedenceInput, QueryPrecedenceOutput] +RECURSIVE_SHAPES: APIOperation[RecursiveShapesInput, RecursiveShapesOutput] +RESPONSE_CODE_HTTP_FALLBACK: APIOperation[ + ResponseCodeHttpFallbackInput, ResponseCodeHttpFallbackOutput +] +RESPONSE_CODE_REQUIRED: APIOperation[ + ResponseCodeRequiredInput, ResponseCodeRequiredOutput +] +SIMPLE_SCALAR_PROPERTIES: APIOperation[ + SimpleScalarPropertiesInput, SimpleScalarPropertiesOutput +] +SPARSE_JSON_LISTS: APIOperation[SparseJsonListsInput, SparseJsonListsOutput] +SPARSE_JSON_MAPS: APIOperation[SparseJsonMapsInput, SparseJsonMapsOutput] +TEST_BODY_STRUCTURE: APIOperation[TestBodyStructureInput, TestBodyStructureOutput] +TEST_GET_NO_INPUT_NO_PAYLOAD: APIOperation[ + TestGetNoInputNoPayloadInput, TestGetNoInputNoPayloadOutput +] +TEST_GET_NO_PAYLOAD: APIOperation[TestGetNoPayloadInput, TestGetNoPayloadOutput] +TEST_PAYLOAD_BLOB: APIOperation[TestPayloadBlobInput, TestPayloadBlobOutput] +TEST_PAYLOAD_STRUCTURE: APIOperation[ + TestPayloadStructureInput, TestPayloadStructureOutput +] +TEST_POST_NO_INPUT_NO_PAYLOAD: APIOperation[ + TestPostNoInputNoPayloadInput, TestPostNoInputNoPayloadOutput +] +TEST_POST_NO_PAYLOAD: APIOperation[TestPostNoPayloadInput, TestPostNoPayloadOutput] +TIMESTAMP_FORMAT_HEADERS: APIOperation[ + TimestampFormatHeadersInput, TimestampFormatHeadersOutput +] +UNIT_INPUT_AND_OUTPUT: APIOperation[UnitInputAndOutputInput, UnitInputAndOutputOutput] diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/py.typed b/codegen-output-py/rest-json-1-client/src/restjson_client/py.typed new file mode 100644 index 000000000..e69de29bb diff --git a/codegen-output-py/rest-json-1-client/src/restjson_client/user_agent.py b/codegen-output-py/rest-json-1-client/src/restjson_client/user_agent.py new file mode 100644 index 000000000..56ab227ea --- /dev/null +++ b/codegen-output-py/rest-json-1-client/src/restjson_client/user_agent.py @@ -0,0 +1,16 @@ +from smithy_aws_core.interceptors.user_agent import UserAgentInterceptor + +from restjson_client import __version__ +from restjson_client.config import RestJsonProtocolConfig + + +def aws_user_agent_plugin(config: RestJsonProtocolConfig) -> None: + "Send the AWS user agent with every request." + config.interceptors.append( + UserAgentInterceptor( + ua_suffix=config.user_agent_extra, + ua_app_id=config.sdk_ua_app_id, + sdk_version=__version__, + service_id="Rest_Json_Protocol", + ) + ) diff --git a/designs/codegen/client.md b/designs/codegen/client.md index f091ae9c7..461f30436 100644 --- a/designs/codegen/client.md +++ b/designs/codegen/client.md @@ -171,21 +171,26 @@ those definitions out. A protocol registry maps modeled protocol IDs to protocol contributions. A contribution provides sync/async protocol and transport references and their -dependencies. RPCv2 CBOR and RPCv2 JSON are built in. Tests can inject a registry. +dependencies. RPCv2 CBOR and RPCv2 JSON are built in. The CLI uses +`smithy_python.aws.AWS_PROTOCOLS`, which adds AWS restJson1. Tests can inject a +registry. The plan keeps the registry's protocol traits in the service schema, +even when the model omits their definitions. An explicit protocol selection must be modeled on the service and present in the registry. Without one, the generator selects the sole supported modeled protocol. Ambiguous or unsupported selections fail before publication. Selection is independent of hash and discovery order. -The built-in contributions use these runtime protocols: +The contributions use these runtime protocols: -| Protocol | Sync | Async | `smithy-http` extra | +| Protocol | Sync | Async | Runtime extra | | --- | --- | --- | --- | -| `smithy.protocols#rpcv2Cbor` | `RpcV2CborClientProtocol` | `AsyncRpcV2CborClientProtocol` | `cbor` | -| `smithy.protocols#rpcv2Json` | `RpcV2JsonClientProtocol` | `AsyncRpcV2JsonClientProtocol` | `json` | +| `smithy.protocols#rpcv2Cbor` | `RpcV2CborClientProtocol` | `AsyncRpcV2CborClientProtocol` | `smithy-http[cbor]` | +| `smithy.protocols#rpcv2Json` | `RpcV2JsonClientProtocol` | `AsyncRpcV2JsonClientProtocol` | `smithy-http[json]` | +| `aws.protocols#restJson1` | `RestJsonClientProtocol` | `AsyncRestJsonClientProtocol` | `smithy-aws-core[json]` | -Both also use: +The restJson1 protocols come from `smithy-aws-core`, as in the Java generator. +All also use: * `ProtocolSettings` with the service namespace, target, version, and schema. * `Urllib3HTTPClient` and `AIOHTTPClient` as default sync/async transports, diff --git a/designs/codegen/snapshots.md b/designs/codegen/snapshots.md index 7f08b957a..450d55a12 100644 --- a/designs/codegen/snapshots.md +++ b/designs/codegen/snapshots.md @@ -62,6 +62,7 @@ projections, generated with the public `client` command. | Projection | Import package | Operations | Protocol vectors | | --- | --- | ---: | ---: | +| `rest-json-1-client` | `restjson_client` | 103 | 236 | | `rpcv2-cbor-client` | `rpcv2cbor_client` | 14 | 72 | | `rpcv2-json-client` | `rpcv2json_client` | 15 | 73 | @@ -69,7 +70,9 @@ Each reuses the model input of the types projection with the same base name. Its import package differs from the types snapshot's, so both resolve in one Pyright project. Each client snapshot adds `client.py`, `config.py`, and their `aio` counterparts to the types files, plus service and operation schemas and lazy -operation exports. Tests compare the RPCv2 CBOR client's operation methods with +operation exports. A projection's `omitOperations` removes service operations +that need features client generation doesn't support yet. `rest-json-1-client` +omits its 10 streaming operations and their 8 vectors. Tests compare the RPCv2 CBOR client's operation methods with the Java client and send one call through fake sync and async transports. ## Inputs and maintenance @@ -91,9 +94,12 @@ The models used by client projections also keep their client protocol vectors in declares them. Server-only vectors are left out. `models/provenance.json` records each file's hash. `tests/test_client_protocol_vectors.py` runs every vector through the sync and async clients of the matching snapshot. A request vector -checks the method, path, headers, and decoded body the client sends. A response +checks the method, host, path, query, headers, and body the client sends. JSON +and CBOR bodies are compared decoded, and other bodies as bytes. A response +vector's request is the smallest input the operation accepts. A response vector checks the output model or error it returns. Vectors that the Java client -also fails are marked as strict expected failures. +also fails or skips, and known runtime gaps, are marked as strict expected +failures. To refresh reference inputs when their models change, obtain assembled JSON ASTs and run: diff --git a/packages/smithy-python/.changes/next-release/smithy-python-feature-4d8e3a0814104a749462bef25fdfeda5.json b/packages/smithy-python/.changes/next-release/smithy-python-feature-4d8e3a0814104a749462bef25fdfeda5.json new file mode 100644 index 000000000..83c575cc7 --- /dev/null +++ b/packages/smithy-python/.changes/next-release/smithy-python-feature-4d8e3a0814104a749462bef25fdfeda5.json @@ -0,0 +1,4 @@ +{ + "type": "feature", + "description": "Added `aws.protocols#restJson1` support to generated clients, using the `smithy-aws-core` REST JSON protocol." +} \ No newline at end of file diff --git a/packages/smithy-python/src/smithy_python/aws/__init__.py b/packages/smithy-python/src/smithy_python/aws/__init__.py index 21e9ef176..0a7124e31 100644 --- a/packages/smithy-python/src/smithy_python/aws/__init__.py +++ b/packages/smithy-python/src/smithy_python/aws/__init__.py @@ -7,6 +7,7 @@ send the AWS user agent. A service with the ``aws.auth#sigv4`` trait also gets SigV4 auth and the default AWS credentials chain. AWS services, and services whose rules use AWS functions or built-ins, resolve endpoints with the AWS rules extension. +Clients may also use the AWS protocols, such as ``aws.protocols#restJson1``. """ from __future__ import annotations @@ -16,10 +17,13 @@ from ._config import AwsConfigIntegration from ._dependencies import SMITHY_AWS_CORE from ._endpoints import AwsEndpointsIntegration +from ._protocols import AWS_PROTOCOLS, REST_JSON from ._sigv4 import AwsSigV4Integration __all__ = [ "AWS_INTEGRATIONS", + "AWS_PROTOCOLS", + "REST_JSON", "SMITHY_AWS_CORE", "AwsConfigIntegration", "AwsEndpointsIntegration", diff --git a/packages/smithy-python/src/smithy_python/aws/_protocols.py b/packages/smithy-python/src/smithy_python/aws/_protocols.py new file mode 100644 index 000000000..62f984bfe --- /dev/null +++ b/packages/smithy-python/src/smithy_python/aws/_protocols.py @@ -0,0 +1,45 @@ +# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. +# SPDX-License-Identifier: Apache-2.0 +"""AWS protocols for generated clients.""" + +from __future__ import annotations + +from collections.abc import Mapping +from types import MappingProxyType +from typing import Final + +from .. import model as _model +from ..dependencies import Dependency +from ..protocols import DEFAULT_PROTOCOLS, RPCV2_CBOR, ProtocolContribution +from ..symbols import TypeReference +from ._dependencies import SMITHY_AWS_CORE + + +def _aws(name: str, module: str, extra: str) -> TypeReference: + return TypeReference( + name, + f"smithy_aws_core.{module}", + dependencies=( + Dependency( + package=SMITHY_AWS_CORE.package, + specifier=SMITHY_AWS_CORE.specifier, + group="runtime", + extras=(extra,), + ), + ), + ) + + +REST_JSON: Final = ProtocolContribution( + protocol_id=_model.ShapeId("aws.protocols", "restJson1"), + protocol=_aws("RestJsonClientProtocol", "protocols", "json"), + async_protocol=_aws("AsyncRestJsonClientProtocol", "aio.protocols", "json"), + transport=RPCV2_CBOR.transport, + async_transport=RPCV2_CBOR.async_transport, +) +"""The ``aws.protocols#restJson1`` contribution.""" + +AWS_PROTOCOLS: Final[Mapping[_model.ShapeId, ProtocolContribution]] = MappingProxyType( + {**DEFAULT_PROTOCOLS, REST_JSON.protocol_id: REST_JSON} +) +"""The core protocols and the AWS protocols.""" diff --git a/packages/smithy-python/src/smithy_python/cli.py b/packages/smithy-python/src/smithy_python/cli.py index df62dc35c..f1fb65828 100644 --- a/packages/smithy-python/src/smithy_python/cli.py +++ b/packages/smithy-python/src/smithy_python/cli.py @@ -285,10 +285,14 @@ def _generate_client( protocol=args.protocol, ) try: - plan = _clients.ClientPlan.from_model(model, settings, service_id=args.service) + plan = _clients.ClientPlan.from_model( + model, settings, service_id=args.service, protocols=_aws.AWS_PROTOCOLS + ) except ValueError as error: raise InvalidInvocationError(str(error)) from error - generator = _clients.ClientGenerator(plan, integrations=_aws.AWS_INTEGRATIONS) + generator = _clients.ClientGenerator( + plan, protocols=_aws.AWS_PROTOCOLS, integrations=_aws.AWS_INTEGRATIONS + ) context = generator.context() generator.generate(context) context.files.commit(output_dir) diff --git a/packages/smithy-python/src/smithy_python/clients.py b/packages/smithy-python/src/smithy_python/clients.py index 99cc1f8d0..cd45cbec1 100644 --- a/packages/smithy-python/src/smithy_python/clients.py +++ b/packages/smithy-python/src/smithy_python/clients.py @@ -5,7 +5,7 @@ from __future__ import annotations from collections import Counter -from collections.abc import Mapping, Sequence +from collections.abc import Collection, Mapping, Sequence from dataclasses import dataclass, replace from types import MappingProxyType @@ -125,8 +125,13 @@ def from_model( settings: _generation.ClientSettings, *, service_id: str | None = None, + protocols: Collection[_model.ShapeId] = _protocols.DEFAULT_PROTOCOLS, ) -> ClientPlan: - """Resolve a service, normalize its I/O, and plan in deterministic order.""" + """Resolve a service, normalize its I/O, and plan in deterministic order. + + :param protocols: The IDs of the protocols the client may use, whose + traits the service schema keeps. + """ selection = _selection.select_shapes( model, service_id=service_id, require_service=True ) @@ -150,7 +155,7 @@ def from_model( (*selection.shapes, *operations, service), symbols, retained_traits=( - *_protocols.DEFAULT_PROTOCOLS, + *protocols, *(() if settings.protocol is None else (settings.protocol,)), ), ) diff --git a/packages/smithy-python/tests/unit/test_client_generation.py b/packages/smithy-python/tests/unit/test_client_generation.py index 8fedf99c3..999c621e8 100644 --- a/packages/smithy-python/tests/unit/test_client_generation.py +++ b/packages/smithy-python/tests/unit/test_client_generation.py @@ -671,6 +671,41 @@ def test_aws_services_get_named_resolving_clients(tmp_path: Path) -> None: assert '"smithy-aws-core~=0.16.0",' in (tmp_path / "pyproject.toml").read_text() +def test_rest_json_services_use_the_aws_core_protocol(tmp_path: Path) -> None: + shapes = _shapes() + shapes["example#Greeter"]["traits"] = {"aws.protocols#restJson1": {}} + shapes["example#Greet"]["traits"] = { + "smithy.api#http": {"method": "POST", "uri": "/greet"} + } + with pytest.raises(CodegenError, match="has no supported protocol"): + _generate(tmp_path / "core", "greeter_core", shapes) + + model = load_model({"smithy": "2.0", "shapes": shapes}) + settings = ClientSettings("greeter_rest", "1.0.0", None) + generator = ClientGenerator( + ClientPlan.from_model(model, settings, protocols=_aws.AWS_PROTOCOLS), + protocols=_aws.AWS_PROTOCOLS, + ) + context = generator.context() + generator.generate(context) + output = tmp_path / "rest" + context.files.commit(output) + source = output / "src/greeter_rest" + assert ( + "RestJsonClientProtocol(_PROTOCOL_SETTINGS)" + in (source / "config.py").read_text() + ) + assert ( + "AsyncRestJsonClientProtocol(_PROTOCOL_SETTINGS)" + in (source / "aio/config.py").read_text() + ) + assert '"smithy-aws-core[json]~=0.16.0",' in (output / "pyproject.toml").read_text() + # The service schema keeps the protocol trait, which the AST doesn't define. + assert "aws.protocols#restJson1" in "".join( + path.read_text() for path in (source / "_private").glob("schemas*.py") + ) + + def test_integrations_apply_only_to_services_they_match(tmp_path: Path) -> None: _aws_generate(tmp_path, "greeter_plain", _shapes()) assert "class Config:" in (tmp_path / "src/greeter_plain/config.py").read_text() diff --git a/scripts/api-snapshot/api-rex.json b/scripts/api-snapshot/api-rex.json index 812cab85c..a52249f03 100644 --- a/scripts/api-snapshot/api-rex.json +++ b/scripts/api-snapshot/api-rex.json @@ -1332,6 +1332,7 @@ "AwsConfigIntegration": "rex-class", "AwsEndpointsIntegration": "rex-class", "AwsSigV4Integration": "rex-class", + "REST_JSON": "rex-ProtocolContribution", "SMITHY_AWS_CORE": "rex-Dependency" }, "smithy_python.cli": { diff --git a/scripts/codegen-output-py/client-projections.json b/scripts/codegen-output-py/client-projections.json index 79f84f065..273b3f680 100644 --- a/scripts/codegen-output-py/client-projections.json +++ b/scripts/codegen-output-py/client-projections.json @@ -6,6 +6,25 @@ "service": "example.features#FieldNotes", "version": "0.0.1" }, + "rest-json-1-client": { + "description": "Python client for the rest-json-1 projection", + "model": "models/rest-json-1.json", + "omitOperations": [ + "aws.protocoltests.restjson#DuplexStream", + "aws.protocoltests.restjson#DuplexStreamWithDistinctStreams", + "aws.protocoltests.restjson#DuplexStreamWithInitialMessages", + "aws.protocoltests.restjson#InputStream", + "aws.protocoltests.restjson#InputStreamWithInitialRequest", + "aws.protocoltests.restjson#OutputStream", + "aws.protocoltests.restjson#OutputStreamWithInitialResponse", + "aws.protocoltests.restjson#StreamingTraits", + "aws.protocoltests.restjson#StreamingTraitsRequireLength", + "aws.protocoltests.restjson#StreamingTraitsWithMediaType" + ], + "package": "restjson_client", + "service": "aws.protocoltests.restjson#RestJson", + "version": "0.0.1" + }, "rpcv2-cbor-client": { "description": "Python client for the rpcv2-cbor projection", "model": "models/rpcv2-cbor.json", diff --git a/scripts/codegen-output-py/generate.py b/scripts/codegen-output-py/generate.py index 065966b3d..f349d3f45 100644 --- a/scripts/codegen-output-py/generate.py +++ b/scripts/codegen-output-py/generate.py @@ -11,6 +11,7 @@ import sys from pathlib import Path from tempfile import TemporaryDirectory +from typing import Any from smithy_python.cli import main as generate @@ -33,17 +34,24 @@ def main() -> None: args = parser.parse_args() # A fresh tree also detects removed projections and obsolete partitions. - with TemporaryDirectory(prefix="smithy-python-snapshots-") as temporary: + with ( + TemporaryDirectory(prefix="smithy-python-snapshots-") as temporary, + TemporaryDirectory(prefix="smithy-python-models-") as models, + ): staged = Path(temporary) for artifact, inputs, options in _ARTIFACTS: projections = json.loads((_INPUTS / inputs).read_text()) for name, settings in sorted(projections.items()): + model = _INPUTS / settings["model"] + if "omitOperations" in settings: + model = Path(models) / f"{name}.json" + model.write_text(json.dumps(projection_model(settings))) result = generate( ( "generate", artifact, "--model", - str(_INPUTS / settings["model"]), + str(model), "--output", str(staged / name), "--service", @@ -86,6 +94,23 @@ def main() -> None: sys.stdout.write("codegen-output-py is up to date; no files changed.\n") +def projection_model(settings: dict[str, Any]) -> dict[str, Any]: + """A projection's model AST, without the service operations it omits. + + A client projection omits the operations that need features client + generation doesn't support yet, such as streaming. + """ + model: dict[str, Any] = json.loads((_INPUTS / settings["model"]).read_text()) + omitted = set(settings.get("omitOperations", ())) + service = model["shapes"][settings["service"]] + service["operations"] = [ + operation + for operation in service.get("operations", ()) + if operation["target"] not in omitted + ] + return model + + def _files(root: Path) -> dict[str, bytes]: return { path.relative_to(root).as_posix(): path.read_bytes() diff --git a/scripts/codegen-output-py/models/provenance.json b/scripts/codegen-output-py/models/provenance.json index e11145a66..0f122a0ae 100644 --- a/scripts/codegen-output-py/models/provenance.json +++ b/scripts/codegen-output-py/models/provenance.json @@ -37,7 +37,8 @@ }, "rest-json-1": { "assembled_sha256": "e9bd8f77892be7064088fd1fcd8f3add141d1ea5c60ff7740a8910c0159874b5", - "fixture_sha256": "86695cc8ccebcb8579cee0a52e9fe891bf7745576496e23c6e6a3f328b4c2231" + "fixture_sha256": "86695cc8ccebcb8579cee0a52e9fe891bf7745576496e23c6e6a3f328b4c2231", + "vectors_sha256": "5a6ad5f85e067099af65e0df4de3a9d8c6c8a22ce51f622998570571199858f0" }, "rest-xml": { "assembled_sha256": "9baf7dd1c331a2c3c4a72b7ab38288a714511b4926ee8a03c8aa4256538b3588", diff --git a/scripts/codegen-output-py/models/vectors/rest-json-1.json b/scripts/codegen-output-py/models/vectors/rest-json-1.json new file mode 100644 index 000000000..6d3ea7bea --- /dev/null +++ b/scripts/codegen-output-py/models/vectors/rest-json-1.json @@ -0,0 +1,4871 @@ +{ + "aws.protocoltests.restjson#AllQueryStringTypes": { + "requests": [ + { + "body": "", + "documentation": "Serializes query string parameters with all supported types", + "id": "RestJsonAllQueryStringTypes", + "method": "GET", + "params": { + "queryBoolean": true, + "queryBooleanList": [ + true, + false, + true + ], + "queryByte": 1, + "queryDouble": 1.1, + "queryDoubleList": [ + 1.1, + 2.1, + 3.1 + ], + "queryEnum": "Foo", + "queryEnumList": [ + "Foo", + "Baz", + "Bar" + ], + "queryFloat": 1.1, + "queryInteger": 3, + "queryIntegerEnum": 1, + "queryIntegerEnumList": [ + 1, + 2, + 3 + ], + "queryIntegerList": [ + 1, + 2, + 3 + ], + "queryIntegerSet": [ + 1, + 2, + 3 + ], + "queryLong": 4, + "queryParamsMapOfStringList": { + "Boolean": [ + "true" + ], + "BooleanList": [ + "true", + "false", + "true" + ], + "Byte": [ + "1" + ], + "Double": [ + "1.1" + ], + "DoubleList": [ + "1.1", + "2.1", + "3.1" + ], + "Enum": [ + "Foo" + ], + "EnumList": [ + "Foo", + "Baz", + "Bar" + ], + "Float": [ + "1.1" + ], + "Integer": [ + "3" + ], + "IntegerEnum": [ + "1" + ], + "IntegerEnumList": [ + "1", + "2", + "3" + ], + "IntegerList": [ + "1", + "2", + "3" + ], + "IntegerSet": [ + "1", + "2", + "3" + ], + "Long": [ + "4" + ], + "Short": [ + "2" + ], + "String": [ + "Hello there" + ], + "StringList": [ + "a", + "b", + "c" + ], + "StringSet": [ + "a", + "b", + "c" + ], + "Timestamp": [ + "1970-01-01T00:00:01Z" + ], + "TimestampList": [ + "1970-01-01T00:00:01Z", + "1970-01-01T00:00:02Z", + "1970-01-01T00:00:03Z" + ] + }, + "queryShort": 2, + "queryString": "Hello there", + "queryStringList": [ + "a", + "b", + "c" + ], + "queryStringSet": [ + "a", + "b", + "c" + ], + "queryTimestamp": 1, + "queryTimestampList": [ + 1, + 2, + 3 + ] + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "String=Hello%20there", + "StringList=a", + "StringList=b", + "StringList=c", + "StringSet=a", + "StringSet=b", + "StringSet=c", + "Byte=1", + "Short=2", + "Integer=3", + "IntegerList=1", + "IntegerList=2", + "IntegerList=3", + "IntegerSet=1", + "IntegerSet=2", + "IntegerSet=3", + "Long=4", + "Float=1.1", + "Double=1.1", + "DoubleList=1.1", + "DoubleList=2.1", + "DoubleList=3.1", + "Boolean=true", + "BooleanList=true", + "BooleanList=false", + "BooleanList=true", + "Timestamp=1970-01-01T00%3A00%3A01Z", + "TimestampList=1970-01-01T00%3A00%3A01Z", + "TimestampList=1970-01-01T00%3A00%3A02Z", + "TimestampList=1970-01-01T00%3A00%3A03Z", + "Enum=Foo", + "EnumList=Foo", + "EnumList=Baz", + "EnumList=Bar", + "IntegerEnum=1", + "IntegerEnumList=1", + "IntegerEnumList=2", + "IntegerEnumList=3" + ], + "uri": "/AllQueryStringTypesInput" + }, + { + "body": "", + "documentation": "Handles query string maps", + "id": "RestJsonQueryStringMap", + "method": "GET", + "params": { + "queryParamsMapOfStringList": { + "QueryParamsStringKeyA": [ + "Foo" + ], + "QueryParamsStringKeyB": [ + "Bar" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "QueryParamsStringKeyA=Foo", + "QueryParamsStringKeyB=Bar" + ], + "uri": "/AllQueryStringTypesInput" + }, + { + "body": "", + "documentation": "Handles escaping all required characters in the query string.", + "id": "RestJsonQueryStringEscaping", + "method": "GET", + "params": { + "queryParamsMapOfStringList": { + "String": [ + " %:/?#[]@!$&'()*+,;=\ud83d\ude39" + ] + }, + "queryString": " %:/?#[]@!$&'()*+,;=\ud83d\ude39" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "String=%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9" + ], + "uri": "/AllQueryStringTypesInput" + }, + { + "body": "", + "documentation": "Supports handling NaN float query values.", + "id": "RestJsonSupportsNaNFloatQueryValues", + "method": "GET", + "params": { + "queryDouble": "NaN", + "queryFloat": "NaN", + "queryParamsMapOfStringList": { + "Double": [ + "NaN" + ], + "Float": [ + "NaN" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "Float=NaN", + "Double=NaN" + ], + "uri": "/AllQueryStringTypesInput" + }, + { + "body": "", + "documentation": "Supports handling Infinity float query values.", + "id": "RestJsonSupportsInfinityFloatQueryValues", + "method": "GET", + "params": { + "queryDouble": "Infinity", + "queryFloat": "Infinity", + "queryParamsMapOfStringList": { + "Double": [ + "Infinity" + ], + "Float": [ + "Infinity" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "Float=Infinity", + "Double=Infinity" + ], + "uri": "/AllQueryStringTypesInput" + }, + { + "body": "", + "documentation": "Supports handling -Infinity float query values.", + "id": "RestJsonSupportsNegativeInfinityFloatQueryValues", + "method": "GET", + "params": { + "queryDouble": "-Infinity", + "queryFloat": "-Infinity", + "queryParamsMapOfStringList": { + "Double": [ + "-Infinity" + ], + "Float": [ + "-Infinity" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "Float=-Infinity", + "Double=-Infinity" + ], + "uri": "/AllQueryStringTypesInput" + }, + { + "body": "", + "documentation": "Query values of 0 and false are serialized", + "id": "RestJsonZeroAndFalseQueryValues", + "method": "GET", + "params": { + "queryBoolean": false, + "queryInteger": 0, + "queryParamsMapOfStringList": { + "Boolean": [ + "false" + ], + "Integer": [ + "0" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "Integer=0", + "Boolean=false" + ], + "uri": "/AllQueryStringTypesInput" + } + ] + }, + "aws.protocoltests.restjson#ComplexError": { + "responses": [ + { + "body": "{\n \"TopLevel\": \"Top level\",\n \"Nested\": {\n \"Fooooo\": \"bar\"\n }\n}", + "bodyMediaType": "application/json", + "code": 403, + "documentation": "Serializes a complex error with no message member", + "headers": { + "Content-Type": "application/json", + "X-Amzn-Errortype": "ComplexError", + "X-Header": "Header" + }, + "id": "RestJsonComplexErrorWithNoMessage", + "params": { + "Header": "Header", + "Nested": { + "Foo": "bar" + }, + "TopLevel": "Top level" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{}", + "bodyMediaType": "application/json", + "code": 403, + "headers": { + "Content-Type": "application/json", + "X-Amzn-Errortype": "ComplexError" + }, + "id": "RestJsonEmptyComplexErrorWithNoMessage", + "params": {}, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#ConstantAndVariableQueryString": { + "requests": [ + { + "body": "", + "documentation": "Mixes constant and variable query string parameters", + "forbidQueryParams": [ + "maybeSet" + ], + "id": "RestJsonConstantAndVariableQueryStringMissingOneValue", + "method": "GET", + "params": { + "baz": "bam" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "foo=bar", + "baz=bam" + ], + "uri": "/ConstantAndVariableQueryString" + }, + { + "body": "", + "documentation": "Mixes constant and variable query string parameters", + "id": "RestJsonConstantAndVariableQueryStringAllValues", + "method": "GET", + "params": { + "baz": "bam", + "maybeSet": "yes" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "foo=bar", + "baz=bam", + "maybeSet=yes" + ], + "uri": "/ConstantAndVariableQueryString" + } + ] + }, + "aws.protocoltests.restjson#ConstantQueryString": { + "requests": [ + { + "body": "", + "documentation": "Includes constant query string parameters", + "id": "RestJsonConstantQueryString", + "method": "GET", + "params": { + "hello": "hi" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "foo=bar", + "hello" + ], + "uri": "/ConstantQueryString/hi" + } + ] + }, + "aws.protocoltests.restjson#DatetimeOffsets": { + "responses": [ + { + "appliesTo": "client", + "body": " {\n \"datetime\": \"2019-12-16T22:48:18-01:00\"\n }\n", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that clients can correctly parse datetime (timestamps) with offsets", + "id": "RestJsonDateTimeWithNegativeOffset", + "params": { + "datetime": 1576540098 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": " {\n \"datetime\": \"2019-12-17T00:48:18+01:00\"\n }\n", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that clients can correctly parse datetime (timestamps) with offsets", + "id": "RestJsonDateTimeWithPositiveOffset", + "params": { + "datetime": 1576540098 + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#DocumentType": { + "requests": [ + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": {\n \"foo\": \"bar\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes document types as part of the JSON request payload with no escaping.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentTypeInputWithObject", + "method": "PUT", + "params": { + "documentValue": { + "foo": "bar" + }, + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentType" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": \"hello\"\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes document types using a string.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentInputWithString", + "method": "PUT", + "params": { + "documentValue": "hello", + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentType" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": 10\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes document types using a number.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentInputWithNumber", + "method": "PUT", + "params": { + "documentValue": 10, + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentType" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": true\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes document types using a boolean.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentInputWithBoolean", + "method": "PUT", + "params": { + "documentValue": true, + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentType" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": [\n true,\n \"hi\",\n [\n 1,\n 2\n ],\n {\n \"foo\": {\n \"baz\": [\n 3,\n 4\n ]\n }\n }\n ]\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes document types using a list.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentInputWithList", + "method": "PUT", + "params": { + "documentValue": [ + true, + "hi", + [ + 1, + 2 + ], + { + "foo": { + "baz": [ + 3, + 4 + ] + } + } + ], + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentType" + } + ], + "responses": [ + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": {\n \"foo\": \"bar\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes documents as part of the JSON response payload with no escaping.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentOutput", + "params": { + "documentValue": { + "foo": "bar" + }, + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": \"hello\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Document types can be JSON scalars too.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentOutputString", + "params": { + "documentValue": "hello", + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": 10\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Document types can be JSON scalars too.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentOutputNumber", + "params": { + "documentValue": 10, + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": false\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Document types can be JSON scalars too.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentOutputBoolean", + "params": { + "documentValue": false, + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"stringValue\": \"string\",\n \"documentValue\": [\n true,\n false\n ]\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Document types can be JSON arrays.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentOutputArray", + "params": { + "documentValue": [ + true, + false + ], + "stringValue": "string" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#DocumentTypeAsMapValue": { + "requests": [ + { + "body": "{\n \"docValuedMap\": {\n \"foo\": { \"f\": 1, \"o\": 2 },\n \"bar\": [ \"b\", \"a\", \"r\" ],\n \"baz\": \"BAZ\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a map that uses documents as the value.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentTypeAsMapValueInput", + "method": "PUT", + "params": { + "docValuedMap": { + "bar": [ + "b", + "a", + "r" + ], + "baz": "BAZ", + "foo": { + "f": 1, + "o": 2 + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentTypeAsMapValue" + } + ], + "responses": [ + { + "body": "{\n \"docValuedMap\": {\n \"foo\": { \"f\": 1, \"o\": 2 },\n \"bar\": [ \"b\", \"a\", \"r\" ],\n \"baz\": \"BAZ\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes a map that uses documents as the value.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentTypeAsMapValueOutput", + "params": { + "docValuedMap": { + "bar": [ + "b", + "a", + "r" + ], + "baz": "BAZ", + "foo": { + "f": 1, + "o": 2 + } + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#DocumentTypeAsPayload": { + "requests": [ + { + "body": "{\n \"foo\": \"bar\"\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a document as the target of the httpPayload trait.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentTypeAsPayloadInput", + "method": "PUT", + "params": { + "documentValue": { + "foo": "bar" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentTypeAsPayload" + }, + { + "body": "\"hello\"", + "bodyMediaType": "application/json", + "documentation": "Serializes a document as the target of the httpPayload trait using a string.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentTypeAsPayloadInputString", + "method": "PUT", + "params": { + "documentValue": "hello" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/DocumentTypeAsPayload" + } + ], + "responses": [ + { + "body": "{\n \"foo\": \"bar\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes a document as the target of the httpPayload trait.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentTypeAsPayloadOutput", + "params": { + "documentValue": { + "foo": "bar" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "\"hello\"", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes a document as a payload string.", + "headers": { + "Content-Type": "application/json" + }, + "id": "DocumentTypeAsPayloadOutputString", + "params": { + "documentValue": "hello" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#EmptyInputAndEmptyOutput": { + "requests": [ + { + "body": "", + "documentation": "Clients should not serialize a JSON payload when no parameters\nare given that are sent in the body. A service will tolerate\nclients that omit a payload or that send a JSON object.", + "id": "RestJsonEmptyInputAndEmptyOutput", + "method": "POST", + "protocol": "aws.protocols#restJson1", + "uri": "/EmptyInputAndEmptyOutput" + } + ], + "responses": [ + { + "body": "{}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "As of January 2021, server implementations are expected to\nrespond with a JSON object regardless of if the output\nparameters are empty.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonEmptyInputAndEmptyOutput", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "", + "code": 200, + "documentation": "This test ensures that clients can gracefully handle\nsituations where a service omits a JSON payload entirely.", + "id": "RestJsonEmptyInputAndEmptyOutputJsonObjectOutput", + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#EndpointOperation": { + "requests": [ + { + "body": "", + "documentation": "Operations can prepend to the given host if they define the\nendpoint trait.", + "host": "example.com", + "id": "RestJsonEndpointTrait", + "method": "POST", + "protocol": "aws.protocols#restJson1", + "resolvedHost": "foo.example.com", + "uri": "/EndpointOperation" + } + ] + }, + "aws.protocoltests.restjson#EndpointWithHostLabelOperation": { + "requests": [ + { + "body": "{\"label\": \"bar\"}", + "bodyMediaType": "application/json", + "documentation": "Operations can prepend to the given host if they define the\nendpoint trait, and can use the host label trait to define\nfurther customization based on user input.", + "host": "example.com", + "id": "RestJsonEndpointTraitWithHostLabel", + "method": "POST", + "params": { + "label": "bar" + }, + "protocol": "aws.protocols#restJson1", + "resolvedHost": "foo.bar.example.com", + "uri": "/EndpointWithHostLabelOperation" + } + ] + }, + "aws.protocoltests.restjson#FooError": { + "responses": [ + { + "appliesTo": "client", + "code": 500, + "documentation": "Serializes the X-Amzn-ErrorType header. For an example service, see Amazon EKS.", + "headers": { + "X-Amzn-Errortype": "FooError" + }, + "id": "RestJsonFooErrorUsingXAmznErrorType", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "code": 500, + "documentation": "Some X-Amzn-Errortype headers contain URLs. Clients need to split the URL on ':' and take only the first half of the string. For example, 'ValidationException:http://internal.amazon.com/coral/com.amazon.coral.validate/'\nis to be interpreted as 'ValidationException'.\n\nFor an example service see Amazon Polly.", + "headers": { + "X-Amzn-Errortype": "FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/" + }, + "id": "RestJsonFooErrorUsingXAmznErrorTypeWithUri", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "code": 500, + "documentation": "X-Amzn-Errortype might contain a URL and a namespace. Client should extract only the shape name. This is a pathalogical case that might not actually happen in any deployed AWS service.", + "headers": { + "X-Amzn-Errortype": "aws.protocoltests.restjson#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/" + }, + "id": "RestJsonFooErrorUsingXAmznErrorTypeWithUriAndNamespace", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "code": 500, + "documentation": "Because namespace and URL are ignored, an unrecognized namespace should not make a difference.", + "headers": { + "X-Amzn-Errortype": "aws.different.namespace#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/" + }, + "id": "RestJsonFooErrorUsingXAmznErrorTypeWithUriAndDifferentNamespace", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"code\": \"FooError\"\n}", + "bodyMediaType": "application/json", + "code": 500, + "documentation": "This example uses the 'code' property in the output rather than X-Amzn-Errortype. Some services do this though it's preferable to send the X-Amzn-Errortype. Client implementations must first check for the X-Amzn-Errortype and then check for a top-level 'code' property.\n\nFor example service see Amazon S3 Glacier.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonFooErrorUsingCode", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"code\": \"aws.protocoltests.restjson#FooError\"\n}", + "bodyMediaType": "application/json", + "code": 500, + "documentation": "Some services serialize errors using code, and it might contain a namespace. Clients should just take the last part of the string after '#'.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonFooErrorUsingCodeAndNamespace", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"code\": \"aws.protocoltests.restjson#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/\"\n}", + "bodyMediaType": "application/json", + "code": 500, + "documentation": "Some services serialize errors using code, and it might contain a namespace. It also might contain a URI. Clients should just take the last part of the string after '#' and before \":\". This is a pathalogical case that might not occur in any deployed AWS service.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonFooErrorUsingCodeUriAndNamespace", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"__type\": \"FooError\"\n}", + "bodyMediaType": "application/json", + "code": 500, + "documentation": "Some services serialize errors using __type.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonFooErrorWithDunderType", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"__type\": \"aws.protocoltests.restjson#FooError\"\n}", + "bodyMediaType": "application/json", + "code": 500, + "documentation": "Some services serialize errors using __type, and it might contain a namespace. Clients should just take the last part of the string after '#'.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonFooErrorWithDunderTypeAndNamespace", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"__type\": \"aws.protocoltests.restjson#FooError:http://internal.amazon.com/coral/com.amazon.coral.validate/\"\n}", + "bodyMediaType": "application/json", + "code": 500, + "documentation": "Some services serialize errors using __type, and it might contain a namespace. It also might contain a URI. Clients should just take the last part of the string after '#' and before \":\". This is a pathalogical case that might not occur in any deployed AWS service.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonFooErrorWithDunderTypeUriAndNamespace", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"__type\": \"aws.protocoltests.restjson#FooError\",\n \"ErrorDetails\": [\n {\n \"__type\": \"com.amazon.internal#ErrorDetails\",\n \"reason\": \"Some reason\"\n }\n ]\n}", + "bodyMediaType": "application/json", + "code": 500, + "documentation": "Some services serialize errors using __type, and if the response includes additional shapes that belong to a different namespace there'll be a nested __type property that must not be considered when determining which error to be surfaced.\n\nFor an example service see Amazon DynamoDB.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonFooErrorWithNestedTypeProperty", + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#FractionalSeconds": { + "responses": [ + { + "appliesTo": "client", + "body": " {\n \"datetime\": \"2000-01-02T20:34:56.123Z\"\n }\n", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that clients can correctly parse datetime timestamps with fractional seconds", + "id": "RestJsonDateTimeWithFractionalSeconds", + "params": { + "datetime": 946845296.123 + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#GreetingWithErrors": { + "responses": [ + { + "body": "{}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that operations with errors successfully know how\nto deserialize a successful response. As of January 2021,\nserver implementations are expected to respond with a\nJSON object regardless of if the output parameters are\nempty.", + "headers": { + "X-Greeting": "Hello" + }, + "id": "RestJsonGreetingWithErrors", + "params": { + "greeting": "Hello" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "", + "code": 200, + "documentation": "This test is similar to RestJsonGreetingWithErrors, but it\nensures that clients can gracefully deal with a server\nomitting a response payload.", + "headers": { + "X-Greeting": "Hello" + }, + "id": "RestJsonGreetingWithErrorsNoPayload", + "params": { + "greeting": "Hello" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HostWithPathOperation": { + "requests": [ + { + "appliesTo": "client", + "body": "", + "documentation": "Custom endpoints supplied by users can have paths", + "host": "example.com/custom", + "id": "RestJsonHostWithPath", + "method": "GET", + "protocol": "aws.protocols#restJson1", + "uri": "/custom/HostWithPathOperation" + } + ] + }, + "aws.protocoltests.restjson#HttpChecksumRequired": { + "requests": [ + { + "body": "{\n \"foo\":\"base64 encoded md5 checksum\"\n}\n", + "bodyMediaType": "application/json", + "documentation": "Adds Content-MD5 header", + "headers": { + "Content-MD5": "iB0/3YSo7maijL0IGOgA9g==", + "Content-Type": "application/json" + }, + "id": "RestJsonHttpChecksumRequired", + "method": "POST", + "params": { + "foo": "base64 encoded md5 checksum" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpChecksumRequired" + } + ] + }, + "aws.protocoltests.restjson#HttpEmptyPrefixHeaders": { + "requests": [ + { + "appliesTo": "client", + "body": "", + "documentation": "Serializes all request headers, using specific when present", + "headers": { + "hello": "There", + "x-foo": "Foo" + }, + "id": "RestJsonHttpEmptyPrefixHeadersRequestClient", + "method": "GET", + "params": { + "prefixHeaders": { + "hello": "Hello", + "x-foo": "Foo" + }, + "specificHeader": "There" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpEmptyPrefixHeaders" + } + ], + "responses": [ + { + "appliesTo": "client", + "code": 200, + "documentation": "Deserializes all response headers with the same for prefix and specific", + "headers": { + "hello": "There", + "x-foo": "Foo" + }, + "id": "RestJsonHttpEmptyPrefixHeadersResponseClient", + "params": { + "prefixHeaders": { + "hello": "There", + "x-foo": "Foo" + }, + "specificHeader": "There" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpEnumPayload": { + "requests": [ + { + "body": "enumvalue", + "headers": { + "Content-Type": "text/plain" + }, + "id": "RestJsonEnumPayloadRequest", + "method": "POST", + "params": { + "payload": "enumvalue" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/EnumPayload" + } + ], + "responses": [ + { + "body": "enumvalue", + "code": 200, + "headers": { + "Content-Type": "text/plain" + }, + "id": "RestJsonEnumPayloadResponse", + "params": { + "payload": "enumvalue" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpPayloadTraits": { + "requests": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes a blob in the HTTP payload", + "headers": { + "Content-Type": "application/octet-stream", + "X-Foo": "Foo" + }, + "id": "RestJsonHttpPayloadTraitsWithBlob", + "method": "POST", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/HttpPayloadTraits" + }, + { + "body": "", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes an empty blob in the HTTP payload", + "headers": { + "X-Foo": "Foo" + }, + "id": "RestJsonHttpPayloadTraitsWithNoBlobBody", + "method": "POST", + "params": { + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpPayloadTraits" + } + ], + "responses": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "code": 200, + "documentation": "Serializes a blob in the HTTP payload", + "headers": { + "X-Foo": "Foo" + }, + "id": "RestJsonHttpPayloadTraitsWithBlob", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "", + "bodyMediaType": "application/octet-stream", + "code": 200, + "documentation": "Serializes an empty blob in the HTTP payload", + "headers": { + "X-Foo": "Foo" + }, + "id": "RestJsonHttpPayloadTraitsWithNoBlobBody", + "params": { + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpPayloadTraitsWithMediaType": { + "requests": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes a blob in the HTTP payload with a content-type", + "headers": { + "Content-Type": "text/plain", + "X-Foo": "Foo" + }, + "id": "RestJsonHttpPayloadTraitsWithMediaTypeWithBlob", + "method": "POST", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/HttpPayloadTraitsWithMediaType" + } + ], + "responses": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "code": 200, + "documentation": "Serializes a blob in the HTTP payload with a content-type", + "headers": { + "Content-Type": "text/plain", + "X-Foo": "Foo" + }, + "id": "RestJsonHttpPayloadTraitsWithMediaTypeWithBlob", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpPayloadWithStructure": { + "requests": [ + { + "body": "{\n \"greeting\": \"hello\",\n \"name\": \"Phreddy\"\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a structure in the payload", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonHttpPayloadWithStructure", + "method": "PUT", + "params": { + "nested": { + "greeting": "hello", + "name": "Phreddy" + } + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/HttpPayloadWithStructure" + } + ], + "responses": [ + { + "body": "{\n \"greeting\": \"hello\",\n \"name\": \"Phreddy\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes a structure in the payload", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonHttpPayloadWithStructure", + "params": { + "nested": { + "greeting": "hello", + "name": "Phreddy" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "", + "code": 200, + "documentation": "Serializes a structure in the payload", + "id": "RestJsonHttpPayloadWithStructureAndEmptyResponseBody", + "params": { + "nested": null + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpPayloadWithUnion": { + "requests": [ + { + "body": "{\n \"greeting\": \"hello\"\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a union in the payload.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonHttpPayloadWithUnion", + "method": "PUT", + "params": { + "nested": { + "greeting": "hello" + } + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/HttpPayloadWithUnion" + }, + { + "body": "", + "documentation": "No payload is sent if the union has no value.", + "id": "RestJsonHttpPayloadWithUnsetUnion", + "method": "PUT", + "params": {}, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpPayloadWithUnion" + } + ], + "responses": [ + { + "body": "{\n \"greeting\": \"hello\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes a union in the payload.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonHttpPayloadWithUnion", + "params": { + "nested": { + "greeting": "hello" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "", + "code": 200, + "documentation": "No payload is sent if the union has no value.", + "headers": { + "Content-Length": "0" + }, + "id": "RestJsonHttpPayloadWithUnsetUnion", + "params": {}, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpPrefixHeaders": { + "requests": [ + { + "body": "", + "documentation": "Adds headers by prefix", + "headers": { + "x-foo": "Foo", + "x-foo-abc": "Abc value", + "x-foo-def": "Def value" + }, + "id": "RestJsonHttpPrefixHeadersArePresent", + "method": "GET", + "params": { + "foo": "Foo", + "fooMap": { + "abc": "Abc value", + "def": "Def value" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpPrefixHeaders" + }, + { + "appliesTo": "client", + "body": "", + "documentation": "No prefix headers are serialized because the value is not present", + "headers": { + "x-foo": "Foo" + }, + "id": "RestJsonHttpPrefixHeadersAreNotPresent", + "method": "GET", + "params": { + "foo": "Foo", + "fooMap": {} + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpPrefixHeaders" + }, + { + "appliesTo": "client", + "body": "", + "documentation": "Serialize prefix headers were the value is present but empty", + "headers": { + "x-foo-abc": "" + }, + "id": "RestJsonHttpPrefixEmptyHeaders", + "method": "GET", + "params": { + "fooMap": { + "abc": "" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpPrefixHeaders" + } + ], + "responses": [ + { + "code": 200, + "documentation": "Adds headers by prefix", + "headers": { + "x-foo": "Foo", + "x-foo-abc": "Abc value", + "x-foo-def": "Def value" + }, + "id": "RestJsonHttpPrefixHeadersArePresent", + "params": { + "foo": "Foo", + "fooMap": { + "abc": "Abc value", + "def": "Def value" + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpPrefixHeadersInResponse": { + "responses": [ + { + "code": 200, + "documentation": "(de)serializes all response headers", + "headers": { + "hello": "Hello", + "x-foo": "Foo" + }, + "id": "HttpPrefixHeadersResponse", + "params": { + "prefixHeaders": { + "hello": "Hello", + "x-foo": "Foo" + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpQueryParamsOnlyOperation": { + "requests": [ + { + "appliesTo": "client", + "documentation": "Test that httpQueryParams are included in request when no other query parameters exist", + "id": "HttpQueryParamsOnlyRequest", + "method": "GET", + "params": { + "queryMap": { + "a": "b", + "c": "d" + } + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "a=b", + "c=d" + ], + "uri": "/http-query-params-only" + }, + { + "appliesTo": "client", + "documentation": "Test that empty httpQueryParams map results in no query parameters", + "id": "HttpQueryParamsOnlyEmptyRequest", + "method": "GET", + "params": { + "queryMap": {} + }, + "protocol": "aws.protocols#restJson1", + "uri": "/http-query-params-only" + } + ] + }, + "aws.protocoltests.restjson#HttpRequestWithFloatLabels": { + "requests": [ + { + "body": "", + "documentation": "Supports handling NaN float label values.", + "id": "RestJsonSupportsNaNFloatLabels", + "method": "GET", + "params": { + "double": "NaN", + "float": "NaN" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/FloatHttpLabels/NaN/NaN" + }, + { + "body": "", + "documentation": "Supports handling Infinity float label values.", + "id": "RestJsonSupportsInfinityFloatLabels", + "method": "GET", + "params": { + "double": "Infinity", + "float": "Infinity" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/FloatHttpLabels/Infinity/Infinity" + }, + { + "body": "", + "documentation": "Supports handling -Infinity float label values.", + "id": "RestJsonSupportsNegativeInfinityFloatLabels", + "method": "GET", + "params": { + "double": "-Infinity", + "float": "-Infinity" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/FloatHttpLabels/-Infinity/-Infinity" + } + ] + }, + "aws.protocoltests.restjson#HttpRequestWithGreedyLabelInPath": { + "requests": [ + { + "body": "", + "documentation": "Serializes greedy labels and normal labels", + "id": "RestJsonHttpRequestWithGreedyLabelInPath", + "method": "GET", + "params": { + "baz": "there/guy", + "foo": "hello/escape" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpRequestWithGreedyLabelInPath/foo/hello%2Fescape/baz/there/guy" + } + ] + }, + "aws.protocoltests.restjson#HttpRequestWithLabels": { + "requests": [ + { + "body": "", + "documentation": "Sends a GET request that uses URI label bindings", + "id": "RestJsonInputWithHeadersAndAllParams", + "method": "GET", + "params": { + "boolean": true, + "double": 5.1, + "float": 4.1, + "integer": 2, + "long": 3, + "short": 1, + "string": "string", + "timestamp": 1576540098 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpRequestWithLabels/string/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z" + }, + { + "body": "", + "documentation": "Sends a GET request that uses URI label bindings", + "id": "RestJsonHttpRequestLabelEscaping", + "method": "GET", + "params": { + "boolean": true, + "double": 5.1, + "float": 4.1, + "integer": 2, + "long": 3, + "short": 1, + "string": " %:/?#[]@!$&'()*+,;=\ud83d\ude39", + "timestamp": 1576540098 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpRequestWithLabels/%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z" + } + ] + }, + "aws.protocoltests.restjson#HttpRequestWithLabelsAndTimestampFormat": { + "requests": [ + { + "body": "", + "documentation": "Serializes different timestamp formats in URI labels", + "id": "RestJsonHttpRequestWithLabelsAndTimestampFormat", + "method": "GET", + "params": { + "defaultFormat": 1576540098, + "memberDateTime": 1576540098, + "memberEpochSeconds": 1576540098, + "memberHttpDate": 1576540098, + "targetDateTime": 1576540098, + "targetEpochSeconds": 1576540098, + "targetHttpDate": 1576540098 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/HttpRequestWithLabelsAndTimestampFormat/1576540098/Mon%2C%2016%20Dec%202019%2023%3A48%3A18%20GMT/2019-12-16T23%3A48%3A18Z/2019-12-16T23%3A48%3A18Z/1576540098/Mon%2C%2016%20Dec%202019%2023%3A48%3A18%20GMT/2019-12-16T23%3A48%3A18Z" + } + ] + }, + "aws.protocoltests.restjson#HttpRequestWithRegexLiteral": { + "requests": [ + { + "body": "", + "documentation": "Path matching is not broken by regex expressions in literal segments", + "id": "RestJsonToleratesRegexCharsInSegments", + "method": "GET", + "params": { + "str": "abc" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/ReDosLiteral/abc/(a+)+" + } + ] + }, + "aws.protocoltests.restjson#HttpResponseCode": { + "responses": [ + { + "body": "{}", + "bodyMediaType": "application/json", + "code": 201, + "documentation": "Binds the http response code to an output structure. Note that\neven though all members are bound outside of the payload, an\nempty JSON object is serialized in the response. However,\nclients should be able to handle an empty JSON object or an\nempty payload without failing to deserialize a response.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonHttpResponseCode", + "params": { + "Status": 201 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "", + "code": 201, + "documentation": "This test ensures that clients gracefully handle cases where\nthe service responds with no payload rather than an empty JSON\nobject.", + "id": "RestJsonHttpResponseCodeWithNoPayload", + "params": { + "Status": 201 + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#HttpStringPayload": { + "requests": [ + { + "body": "rawstring", + "bodyMediaType": "text/plain", + "headers": { + "Content-Type": "text/plain" + }, + "id": "RestJsonStringPayloadRequest", + "method": "POST", + "params": { + "payload": "rawstring" + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/StringPayload" + } + ], + "responses": [ + { + "body": "rawstring", + "bodyMediaType": "text/plain", + "code": 200, + "headers": { + "Content-Type": "text/plain" + }, + "id": "RestJsonStringPayloadResponse", + "params": { + "payload": "rawstring" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#IgnoreQueryParamsInResponse": { + "responses": [ + { + "body": "{\"baz\":\"bam\"}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Query parameters must be ignored when serializing the output\nof an operation. As of January 2021, server implementations\nare expected to respond with a JSON object regardless of\nif the output parameters are empty.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonIgnoreQueryParamsInResponse", + "params": { + "baz": "bam" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#InputAndOutputWithHeaders": { + "requests": [ + { + "body": "", + "documentation": "Tests requests with string header bindings", + "headers": { + "X-String": "Hello", + "X-StringList": "a, b, c", + "X-StringSet": "a, b, c" + }, + "id": "RestJsonInputAndOutputWithStringHeaders", + "method": "POST", + "params": { + "headerString": "Hello", + "headerStringList": [ + "a", + "b", + "c" + ], + "headerStringSet": [ + "a", + "b", + "c" + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Tests requests with string list header bindings that require quoting", + "headers": { + "X-StringList": "\"b,c\", \"\\\"def\\\"\", a" + }, + "id": "RestJsonInputAndOutputWithQuotedStringHeaders", + "method": "POST", + "params": { + "headerStringList": [ + "b,c", + "\"def\"", + "a" + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Tests requests with numeric header bindings", + "headers": { + "X-Byte": "1", + "X-Double": "1.1", + "X-Float": "1.1", + "X-Integer": "123", + "X-IntegerList": "1, 2, 3", + "X-Long": "123", + "X-Short": "123" + }, + "id": "RestJsonInputAndOutputWithNumericHeaders", + "method": "POST", + "params": { + "headerByte": 1, + "headerDouble": 1.1, + "headerFloat": 1.1, + "headerInteger": 123, + "headerIntegerList": [ + 1, + 2, + 3 + ], + "headerLong": 123, + "headerShort": 123 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Tests requests with boolean header bindings", + "headers": { + "X-Boolean1": "true", + "X-Boolean2": "false", + "X-BooleanList": "true, false, true" + }, + "id": "RestJsonInputAndOutputWithBooleanHeaders", + "method": "POST", + "params": { + "headerBooleanList": [ + true, + false, + true + ], + "headerFalseBool": false, + "headerTrueBool": true + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Tests requests with timestamp header bindings", + "headers": { + "X-TimestampList": "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT" + }, + "id": "RestJsonInputAndOutputWithTimestampHeaders", + "method": "POST", + "params": { + "headerTimestampList": [ + 1576540098, + 1576540098 + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Tests requests with enum header bindings", + "headers": { + "X-Enum": "Foo", + "X-EnumList": "Foo, Bar, Baz" + }, + "id": "RestJsonInputAndOutputWithEnumHeaders", + "method": "POST", + "params": { + "headerEnum": "Foo", + "headerEnumList": [ + "Foo", + "Bar", + "Baz" + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Tests requests with intEnum header bindings", + "headers": { + "X-IntegerEnum": "1", + "X-IntegerEnumList": "1, 2, 3" + }, + "id": "RestJsonInputAndOutputWithIntEnumHeaders", + "method": "POST", + "params": { + "headerIntegerEnum": 1, + "headerIntegerEnumList": [ + 1, + 2, + 3 + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Supports handling NaN float header values.", + "headers": { + "X-Double": "NaN", + "X-Float": "NaN" + }, + "id": "RestJsonSupportsNaNFloatHeaderInputs", + "method": "POST", + "params": { + "headerDouble": "NaN", + "headerFloat": "NaN" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Supports handling Infinity float header values.", + "headers": { + "X-Double": "Infinity", + "X-Float": "Infinity" + }, + "id": "RestJsonSupportsInfinityFloatHeaderInputs", + "method": "POST", + "params": { + "headerDouble": "Infinity", + "headerFloat": "Infinity" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + }, + { + "body": "", + "documentation": "Supports handling -Infinity float header values.", + "headers": { + "X-Double": "-Infinity", + "X-Float": "-Infinity" + }, + "id": "RestJsonSupportsNegativeInfinityFloatHeaderInputs", + "method": "POST", + "params": { + "headerDouble": "-Infinity", + "headerFloat": "-Infinity" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/InputAndOutputWithHeaders" + } + ], + "responses": [ + { + "code": 200, + "documentation": "Tests responses with string header bindings", + "headers": { + "X-String": "Hello", + "X-StringList": "a, b, c", + "X-StringSet": "a, b, c" + }, + "id": "RestJsonInputAndOutputWithStringHeaders", + "params": { + "headerString": "Hello", + "headerStringList": [ + "a", + "b", + "c" + ], + "headerStringSet": [ + "a", + "b", + "c" + ] + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Tests responses with string list header bindings that require quoting", + "headers": { + "X-StringList": "\"b,c\", \"\\\"def\\\"\", a" + }, + "id": "RestJsonInputAndOutputWithQuotedStringHeaders", + "params": { + "headerStringList": [ + "b,c", + "\"def\"", + "a" + ] + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Tests responses with numeric header bindings", + "headers": { + "X-Byte": "1", + "X-Double": "1.1", + "X-Float": "1.1", + "X-Integer": "123", + "X-IntegerList": "1, 2, 3", + "X-Long": "123", + "X-Short": "123" + }, + "id": "RestJsonInputAndOutputWithNumericHeaders", + "params": { + "headerByte": 1, + "headerDouble": 1.1, + "headerFloat": 1.1, + "headerInteger": 123, + "headerIntegerList": [ + 1, + 2, + 3 + ], + "headerLong": 123, + "headerShort": 123 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Tests responses with boolean header bindings", + "headers": { + "X-Boolean1": "true", + "X-Boolean2": "false", + "X-BooleanList": "true, false, true" + }, + "id": "RestJsonInputAndOutputWithBooleanHeaders", + "params": { + "headerBooleanList": [ + true, + false, + true + ], + "headerFalseBool": false, + "headerTrueBool": true + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Tests responses with timestamp header bindings", + "headers": { + "X-TimestampList": "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT" + }, + "id": "RestJsonInputAndOutputWithTimestampHeaders", + "params": { + "headerTimestampList": [ + 1576540098, + 1576540098 + ] + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Tests responses with enum header bindings", + "headers": { + "X-Enum": "Foo", + "X-EnumList": "Foo, Bar, Baz" + }, + "id": "RestJsonInputAndOutputWithEnumHeaders", + "params": { + "headerEnum": "Foo", + "headerEnumList": [ + "Foo", + "Bar", + "Baz" + ] + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Tests responses with intEnum header bindings", + "headers": { + "X-IntegerEnum": "1", + "X-IntegerEnumList": "1, 2, 3" + }, + "id": "RestJsonInputAndOutputWithIntEnumHeaders", + "params": { + "headerIntegerEnum": 1, + "headerIntegerEnumList": [ + 1, + 2, + 3 + ] + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Supports handling NaN float header values.", + "headers": { + "X-Double": "NaN", + "X-Float": "NaN" + }, + "id": "RestJsonSupportsNaNFloatHeaderOutputs", + "params": { + "headerDouble": "NaN", + "headerFloat": "NaN" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Supports handling Infinity float header values.", + "headers": { + "X-Double": "Infinity", + "X-Float": "Infinity" + }, + "id": "RestJsonSupportsInfinityFloatHeaderOutputs", + "params": { + "headerDouble": "Infinity", + "headerFloat": "Infinity" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "code": 200, + "documentation": "Supports handling -Infinity float header values.", + "headers": { + "X-Double": "-Infinity", + "X-Float": "-Infinity" + }, + "id": "RestJsonSupportsNegativeInfinityFloatHeaderOutputs", + "params": { + "headerDouble": "-Infinity", + "headerFloat": "-Infinity" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#InvalidGreeting": { + "responses": [ + { + "body": "{\n \"Message\": \"Hi\"\n}", + "bodyMediaType": "application/json", + "code": 400, + "documentation": "Parses simple JSON errors", + "headers": { + "Content-Type": "application/json", + "X-Amzn-Errortype": "InvalidGreeting" + }, + "id": "RestJsonInvalidGreetingError", + "params": { + "Message": "Hi" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#JsonBlobs": { + "requests": [ + { + "body": "{\n \"data\": \"dmFsdWU=\"\n}", + "bodyMediaType": "application/json", + "documentation": "Blobs are base64 encoded", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonBlobs", + "method": "POST", + "params": { + "data": "value" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonBlobs" + } + ], + "responses": [ + { + "body": "{\n \"data\": \"dmFsdWU=\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Blobs are base64 encoded", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonBlobs", + "params": { + "data": "value" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#JsonEnums": { + "requests": [ + { + "body": "{\n \"fooEnum1\": \"Foo\",\n \"fooEnum2\": \"0\",\n \"fooEnum3\": \"1\",\n \"fooEnumList\": [\n \"Foo\",\n \"0\"\n ],\n \"fooEnumSet\": [\n \"Foo\",\n \"0\"\n ],\n \"fooEnumMap\": {\n \"hi\": \"Foo\",\n \"zero\": \"0\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes simple scalar properties", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonEnums", + "method": "PUT", + "params": { + "fooEnum1": "Foo", + "fooEnum2": "0", + "fooEnum3": "1", + "fooEnumList": [ + "Foo", + "0" + ], + "fooEnumMap": { + "hi": "Foo", + "zero": "0" + }, + "fooEnumSet": [ + "Foo", + "0" + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonEnums" + } + ], + "responses": [ + { + "body": "{\n \"fooEnum1\": \"Foo\",\n \"fooEnum2\": \"0\",\n \"fooEnum3\": \"1\",\n \"fooEnumList\": [\n \"Foo\",\n \"0\"\n ],\n \"fooEnumSet\": [\n \"Foo\",\n \"0\"\n ],\n \"fooEnumMap\": {\n \"hi\": \"Foo\",\n \"zero\": \"0\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes simple scalar properties", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonEnums", + "params": { + "fooEnum1": "Foo", + "fooEnum2": "0", + "fooEnum3": "1", + "fooEnumList": [ + "Foo", + "0" + ], + "fooEnumMap": { + "hi": "Foo", + "zero": "0" + }, + "fooEnumSet": [ + "Foo", + "0" + ] + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#JsonIntEnums": { + "requests": [ + { + "body": "{\n \"integerEnum1\": 1,\n \"integerEnum2\": 2,\n \"integerEnum3\": 3,\n \"integerEnumList\": [\n 1,\n 2,\n 3\n ],\n \"integerEnumSet\": [\n 1,\n 2\n ],\n \"integerEnumMap\": {\n \"abc\": 1,\n \"def\": 2\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes intEnums as integers", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonIntEnums", + "method": "PUT", + "params": { + "integerEnum1": 1, + "integerEnum2": 2, + "integerEnum3": 3, + "integerEnumList": [ + 1, + 2, + 3 + ], + "integerEnumMap": { + "abc": 1, + "def": 2 + }, + "integerEnumSet": [ + 1, + 2 + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonIntEnums" + } + ], + "responses": [ + { + "body": "{\n \"integerEnum1\": 1,\n \"integerEnum2\": 2,\n \"integerEnum3\": 3,\n \"integerEnumList\": [\n 1,\n 2,\n 3\n ],\n \"integerEnumSet\": [\n 1,\n 2\n ],\n \"integerEnumMap\": {\n \"abc\": 1,\n \"def\": 2\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes intEnums as integers", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonIntEnums", + "params": { + "integerEnum1": 1, + "integerEnum2": 2, + "integerEnum3": 3, + "integerEnumList": [ + 1, + 2, + 3 + ], + "integerEnumMap": { + "abc": 1, + "def": 2 + }, + "integerEnumSet": [ + 1, + 2 + ] + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#JsonLists": { + "requests": [ + { + "body": "{\n \"stringList\": [\n \"foo\",\n \"bar\"\n ],\n \"stringSet\": [\n \"foo\",\n \"bar\"\n ],\n \"integerList\": [\n 1,\n 2\n ],\n \"booleanList\": [\n true,\n false\n ],\n \"timestampList\": [\n 1398796238,\n 1398796238\n ],\n \"enumList\": [\n \"Foo\",\n \"0\"\n ],\n \"intEnumList\": [\n 1,\n 2\n ],\n \"nestedStringList\": [\n [\n \"foo\",\n \"bar\"\n ],\n [\n \"baz\",\n \"qux\"\n ]\n ],\n \"myStructureList\": [\n {\n \"value\": \"1\",\n \"other\": \"2\"\n },\n {\n \"value\": \"3\",\n \"other\": \"4\"\n }\n ]\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes JSON lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonLists", + "method": "PUT", + "params": { + "booleanList": [ + true, + false + ], + "enumList": [ + "Foo", + "0" + ], + "intEnumList": [ + 1, + 2 + ], + "integerList": [ + 1, + 2 + ], + "nestedStringList": [ + [ + "foo", + "bar" + ], + [ + "baz", + "qux" + ] + ], + "stringList": [ + "foo", + "bar" + ], + "stringSet": [ + "foo", + "bar" + ], + "structureList": [ + { + "a": "1", + "b": "2" + }, + { + "a": "3", + "b": "4" + } + ], + "timestampList": [ + 1398796238, + 1398796238 + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonLists" + }, + { + "body": "{\n \"stringList\": []\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes empty JSON lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonListsEmpty", + "method": "PUT", + "params": { + "stringList": [] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonLists" + } + ], + "responses": [ + { + "body": "{\n \"stringList\": [\n \"foo\",\n \"bar\"\n ],\n \"stringSet\": [\n \"foo\",\n \"bar\"\n ],\n \"integerList\": [\n 1,\n 2\n ],\n \"booleanList\": [\n true,\n false\n ],\n \"timestampList\": [\n 1398796238,\n 1398796238\n ],\n \"enumList\": [\n \"Foo\",\n \"0\"\n ],\n \"intEnumList\": [\n 1,\n 2\n ],\n \"nestedStringList\": [\n [\n \"foo\",\n \"bar\"\n ],\n [\n \"baz\",\n \"qux\"\n ]\n ],\n \"myStructureList\": [\n {\n \"value\": \"1\",\n \"other\": \"2\"\n },\n {\n \"value\": \"3\",\n \"other\": \"4\"\n }\n ]\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes JSON lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonLists", + "params": { + "booleanList": [ + true, + false + ], + "enumList": [ + "Foo", + "0" + ], + "intEnumList": [ + 1, + 2 + ], + "integerList": [ + 1, + 2 + ], + "nestedStringList": [ + [ + "foo", + "bar" + ], + [ + "baz", + "qux" + ] + ], + "stringList": [ + "foo", + "bar" + ], + "stringSet": [ + "foo", + "bar" + ], + "structureList": [ + { + "a": "1", + "b": "2" + }, + { + "a": "3", + "b": "4" + } + ], + "timestampList": [ + 1398796238, + 1398796238 + ] + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"stringList\": []\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes empty JSON lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonListsEmpty", + "params": { + "stringList": [] + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#JsonMaps": { + "requests": [ + { + "body": "{\n \"denseStructMap\": {\n \"foo\": {\n \"hi\": \"there\"\n },\n \"baz\": {\n \"hi\": \"bye\"\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes JSON maps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonMaps", + "method": "POST", + "params": { + "denseStructMap": { + "baz": { + "hi": "bye" + }, + "foo": { + "hi": "there" + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonMaps" + }, + { + "body": "{\n \"denseNumberMap\": {\n \"x\": 0\n },\n \"denseBooleanMap\": {\n \"x\": false\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Ensure that 0 and false are sent over the wire in all maps and lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializesZeroValuesInMaps", + "method": "POST", + "params": { + "denseBooleanMap": { + "x": false + }, + "denseNumberMap": { + "x": 0 + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonMaps" + }, + { + "body": "{\n \"denseSetMap\": {\n \"x\": [],\n \"y\": [\"a\", \"b\"]\n }\n}", + "bodyMediaType": "application/json", + "documentation": "A request that contains a dense map of sets.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializesDenseSetMap", + "method": "POST", + "params": { + "denseSetMap": { + "x": [], + "y": [ + "a", + "b" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonMaps" + } + ], + "responses": [ + { + "body": "{\n \"denseStructMap\": {\n \"foo\": {\n \"hi\": \"there\"\n },\n \"baz\": {\n \"hi\": \"bye\"\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes JSON maps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonMaps", + "params": { + "denseStructMap": { + "baz": { + "hi": "bye" + }, + "foo": { + "hi": "there" + } + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"denseNumberMap\": {\n \"x\": 0\n },\n \"denseBooleanMap\": {\n \"x\": false\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensure that 0 and false are sent over the wire in all maps and lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializesZeroValuesInMaps", + "params": { + "denseBooleanMap": { + "x": false + }, + "denseNumberMap": { + "x": 0 + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"denseSetMap\": {\n \"x\": [],\n \"y\": [\"a\", \"b\"]\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "A response that contains a dense map of sets.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializesDenseSetMap", + "params": { + "denseSetMap": { + "x": [], + "y": [ + "a", + "b" + ] + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#JsonTimestamps": { + "requests": [ + { + "body": "{\n \"normal\": 1398796238\n}", + "bodyMediaType": "application/json", + "documentation": "Tests how normal timestamps are serialized", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestamps", + "method": "POST", + "params": { + "normal": 1398796238 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonTimestamps" + }, + { + "body": "{\n \"dateTime\": \"2014-04-29T18:30:38Z\"\n}", + "bodyMediaType": "application/json", + "documentation": "Ensures that the timestampFormat of date-time works like normal timestamps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithDateTimeFormat", + "method": "POST", + "params": { + "dateTime": 1398796238 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonTimestamps" + }, + { + "body": "{\n \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}", + "bodyMediaType": "application/json", + "documentation": "Ensures that the timestampFormat of date-time on the target shape works like normal timestamps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithDateTimeOnTargetFormat", + "method": "POST", + "params": { + "dateTimeOnTarget": 1398796238 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonTimestamps" + }, + { + "body": "{\n \"epochSeconds\": 1398796238\n}", + "bodyMediaType": "application/json", + "documentation": "Ensures that the timestampFormat of epoch-seconds works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithEpochSecondsFormat", + "method": "POST", + "params": { + "epochSeconds": 1398796238 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonTimestamps" + }, + { + "body": "{\n \"epochSecondsOnTarget\": 1398796238\n}", + "bodyMediaType": "application/json", + "documentation": "Ensures that the timestampFormat of epoch-seconds on the target shape works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat", + "method": "POST", + "params": { + "epochSecondsOnTarget": 1398796238 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonTimestamps" + }, + { + "body": "{\n \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}", + "bodyMediaType": "application/json", + "documentation": "Ensures that the timestampFormat of http-date works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithHttpDateFormat", + "method": "POST", + "params": { + "httpDate": 1398796238 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonTimestamps" + }, + { + "body": "{\n \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}", + "bodyMediaType": "application/json", + "documentation": "Ensures that the timestampFormat of http-date on the target shape works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithHttpDateOnTargetFormat", + "method": "POST", + "params": { + "httpDateOnTarget": 1398796238 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonTimestamps" + } + ], + "responses": [ + { + "body": "{\n \"normal\": 1398796238\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Tests how normal timestamps are serialized", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestamps", + "params": { + "normal": 1398796238 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"dateTime\": \"2014-04-29T18:30:38Z\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that the timestampFormat of date-time works like normal timestamps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithDateTimeFormat", + "params": { + "dateTime": 1398796238 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that the timestampFormat of date-time on the target shape works like normal timestamps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithDateTimeOnTargetFormat", + "params": { + "dateTimeOnTarget": 1398796238 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"epochSeconds\": 1398796238\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that the timestampFormat of epoch-seconds works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithEpochSecondsFormat", + "params": { + "epochSeconds": 1398796238 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"epochSecondsOnTarget\": 1398796238\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that the timestampFormat of epoch-seconds on the target shape works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat", + "params": { + "epochSecondsOnTarget": 1398796238 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that the timestampFormat of http-date works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithHttpDateFormat", + "params": { + "httpDate": 1398796238 + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensures that the timestampFormat of http-date on the target shape works", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonJsonTimestampsWithHttpDateOnTargetFormat", + "params": { + "httpDateOnTarget": 1398796238 + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#JsonUnions": { + "requests": [ + { + "body": "{\n \"contents\": {\n \"stringValue\": \"foo\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a string union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeStringUnionValue", + "method": "PUT", + "params": { + "contents": { + "stringValue": "foo" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"booleanValue\": true\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a boolean union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeBooleanUnionValue", + "method": "PUT", + "params": { + "contents": { + "booleanValue": true + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"numberValue\": 1\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a number union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeNumberUnionValue", + "method": "PUT", + "params": { + "contents": { + "numberValue": 1 + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"blobValue\": \"Zm9v\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a blob union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeBlobUnionValue", + "method": "PUT", + "params": { + "contents": { + "blobValue": "foo" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"timestampValue\": 1398796238\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a timestamp union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeTimestampUnionValue", + "method": "PUT", + "params": { + "contents": { + "timestampValue": 1398796238 + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"enumValue\": \"Foo\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes an enum union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeEnumUnionValue", + "method": "PUT", + "params": { + "contents": { + "enumValue": "Foo" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"listValue\": [\"foo\", \"bar\"]\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a list union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeListUnionValue", + "method": "PUT", + "params": { + "contents": { + "listValue": [ + "foo", + "bar" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"mapValue\": {\n \"foo\": \"bar\",\n \"spam\": \"eggs\"\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a map union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeMapUnionValue", + "method": "PUT", + "params": { + "contents": { + "mapValue": { + "foo": "bar", + "spam": "eggs" + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"structureValue\": {\n \"hi\": \"hello\"\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a structure union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeStructureUnionValue", + "method": "PUT", + "params": { + "contents": { + "structureValue": { + "hi": "hello" + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"renamedStructureValue\": {\n \"salutation\": \"hello!\"\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a renamed structure union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeRenamedStructureUnionValue", + "method": "PUT", + "params": { + "contents": { + "renamedStructureValue": { + "salutation": "hello!" + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + }, + { + "body": "{\n \"contents\": {\n \"unionValue\": {\n \"stringValue\": \"foo\"\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a nested union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializeNestedUnionValue", + "method": "PUT", + "params": { + "contents": { + "unionValue": { + "stringValue": "foo" + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/JsonUnions" + } + ], + "responses": [ + { + "body": "{\n \"contents\": {\n \"stringValue\": \"foo\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a string union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeStringUnionValue", + "params": { + "contents": { + "stringValue": "foo" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"booleanValue\": true\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a boolean union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeBooleanUnionValue", + "params": { + "contents": { + "booleanValue": true + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"numberValue\": 1\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a number union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeNumberUnionValue", + "params": { + "contents": { + "numberValue": 1 + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"blobValue\": \"Zm9v\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a blob union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeBlobUnionValue", + "params": { + "contents": { + "blobValue": "foo" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"timestampValue\": 1398796238\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a timestamp union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeTimestampUnionValue", + "params": { + "contents": { + "timestampValue": 1398796238 + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"enumValue\": \"Foo\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes an enum union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeEnumUnionValue", + "params": { + "contents": { + "enumValue": "Foo" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"listValue\": [\"foo\", \"bar\"]\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a list union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeListUnionValue", + "params": { + "contents": { + "listValue": [ + "foo", + "bar" + ] + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"mapValue\": {\n \"foo\": \"bar\",\n \"spam\": \"eggs\"\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a map union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeMapUnionValue", + "params": { + "contents": { + "mapValue": { + "foo": "bar", + "spam": "eggs" + } + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"structureValue\": {\n \"hi\": \"hello\"\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a structure union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeStructureUnionValue", + "params": { + "contents": { + "structureValue": { + "hi": "hello" + } + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"contents\": {\n \"unionValue\": {\n \"stringValue\": \"foo\"\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes a nested union value", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeNestedUnionValue", + "params": { + "contents": { + "unionValue": { + "stringValue": "foo" + } + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"contents\": {\n \"__type\": \"aws.protocoltests.json10#MyUnion\",\n \"structureValue\": {\n \"hi\": \"hello\"\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ignores an unrecognized __type property", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializeIgnoreType", + "params": { + "contents": { + "structureValue": { + "hi": "hello" + } + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#MediaTypeHeader": { + "requests": [ + { + "body": "", + "documentation": "Headers that target strings with a mediaType are base64 encoded", + "headers": { + "X-Json": "dHJ1ZQ==" + }, + "id": "MediaTypeHeaderInputBase64", + "method": "GET", + "params": { + "json": "true" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/MediaTypeHeader" + } + ], + "responses": [ + { + "code": 200, + "documentation": "Headers that target strings with a mediaType are base64 encoded", + "headers": { + "X-Json": "dHJ1ZQ==" + }, + "id": "MediaTypeHeaderOutputBase64", + "params": { + "json": "true" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#NoInputAndNoOutput": { + "requests": [ + { + "body": "", + "documentation": "No input serializes no payload. When clients do not need to\nserialize any data in the payload, they should omit a payload\naltogether.", + "id": "RestJsonNoInputAndNoOutput", + "method": "POST", + "protocol": "aws.protocols#restJson1", + "uri": "/NoInputAndNoOutput" + } + ], + "responses": [ + { + "body": "", + "code": 200, + "documentation": "When an operation does not define output, the service will respond\nwith an empty payload, and may optionally include the content-type\nheader.", + "id": "RestJsonNoInputAndNoOutput", + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#NoInputAndOutput": { + "requests": [ + { + "body": "", + "documentation": "No input serializes no payload. When clients do not need to\nserialize any data in the payload, they should omit a payload\naltogether.", + "id": "RestJsonNoInputAndOutput", + "method": "POST", + "protocol": "aws.protocols#restJson1", + "uri": "/NoInputAndOutputOutput" + } + ], + "responses": [ + { + "body": "{}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Operations that define output and do not bind anything to\nthe payload return a JSON object in the response.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonNoInputAndOutputWithJson", + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "", + "code": 200, + "documentation": "This test is similar to RestJsonNoInputAndOutputWithJson, but\nit ensures that clients can gracefully handle responses that\nomit a JSON payload.", + "id": "RestJsonNoInputAndOutputNoPayload", + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#NullAndEmptyHeadersClient": { + "requests": [ + { + "appliesTo": "client", + "body": "", + "documentation": "Do not send null values, but do send empty strings and empty lists over the wire in headers", + "forbidHeaders": [ + "X-A" + ], + "headers": { + "X-B": "", + "X-C": "" + }, + "id": "RestJsonNullAndEmptyHeaders", + "method": "GET", + "params": { + "a": null, + "b": "", + "c": [] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/NullAndEmptyHeadersClient" + } + ] + }, + "aws.protocoltests.restjson#OmitsNullSerializesEmptyString": { + "requests": [ + { + "appliesTo": "client", + "body": "", + "documentation": "Omits null query values", + "id": "RestJsonOmitsNullQuery", + "method": "GET", + "params": { + "nullValue": null + }, + "protocol": "aws.protocols#restJson1", + "uri": "/OmitsNullSerializesEmptyString" + }, + { + "body": "", + "documentation": "Serializes empty query strings", + "id": "RestJsonSerializesEmptyQueryValue", + "method": "GET", + "params": { + "emptyString": "" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "Empty=" + ], + "uri": "/OmitsNullSerializesEmptyString" + } + ] + }, + "aws.protocoltests.restjson#OmitsSerializingEmptyLists": { + "requests": [ + { + "body": "", + "documentation": "Supports omitting empty lists.", + "id": "RestJsonOmitsEmptyListQueryValues", + "method": "POST", + "params": { + "queryBooleanList": [], + "queryDoubleList": [], + "queryEnumList": [], + "queryIntegerEnumList": [], + "queryIntegerList": [], + "queryStringList": [], + "queryTimestampList": [] + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [], + "uri": "/OmitsSerializingEmptyLists" + } + ] + }, + "aws.protocoltests.restjson#OperationWithDefaults": { + "requests": [ + { + "appliesTo": "client", + "body": "{\n \"defaults\": {\n \"defaultString\": \"hi\",\n \"defaultBoolean\": true,\n \"defaultList\": [],\n \"defaultDocumentMap\": {},\n \"defaultDocumentString\": \"hi\",\n \"defaultDocumentBoolean\": true,\n \"defaultDocumentList\": [],\n \"defaultTimestamp\": 0,\n \"defaultBlob\": \"YWJj\",\n \"defaultByte\": 1,\n \"defaultShort\": 1,\n \"defaultInteger\": 10,\n \"defaultLong\": 100,\n \"defaultFloat\": 1.0,\n \"defaultDouble\": 1.0,\n \"defaultMap\": {},\n \"defaultEnum\": \"FOO\",\n \"defaultIntEnum\": 1,\n \"emptyString\": \"\",\n \"falseBoolean\": false,\n \"emptyBlob\": \"\",\n \"zeroByte\": 0,\n \"zeroShort\": 0,\n \"zeroInteger\": 0,\n \"zeroLong\": 0,\n \"zeroFloat\": 0.0,\n \"zeroDouble\": 0.0\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Client populates default values in input.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientPopulatesDefaultValuesInInput", + "method": "POST", + "params": { + "defaults": {} + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ], + "uri": "/OperationWithDefaults" + }, + { + "appliesTo": "client", + "body": "{\n}", + "bodyMediaType": "application/json", + "documentation": "Client skips top level default values in input.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientSkipsTopLevelDefaultValuesInInput", + "method": "POST", + "params": {}, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ], + "uri": "/OperationWithDefaults" + }, + { + "appliesTo": "client", + "body": "{\n \"defaults\": {\n \"defaultString\": \"bye\",\n \"defaultBoolean\": true,\n \"defaultList\": [\"a\"],\n \"defaultDocumentMap\": {\"name\": \"Jack\"},\n \"defaultDocumentString\": \"bye\",\n \"defaultDocumentBoolean\": true,\n \"defaultDocumentList\": [\"b\"],\n \"defaultNullDocument\": \"notNull\",\n \"defaultTimestamp\": 1,\n \"defaultBlob\": \"aGk=\",\n \"defaultByte\": 2,\n \"defaultShort\": 2,\n \"defaultInteger\": 20,\n \"defaultLong\": 200,\n \"defaultFloat\": 2.0,\n \"defaultDouble\": 2.0,\n \"defaultMap\": {\"name\": \"Jack\"},\n \"defaultEnum\": \"BAR\",\n \"defaultIntEnum\": 2,\n \"emptyString\": \"foo\",\n \"falseBoolean\": true,\n \"emptyBlob\": \"aGk=\",\n \"zeroByte\": 1,\n \"zeroShort\": 1,\n \"zeroInteger\": 1,\n \"zeroLong\": 1,\n \"zeroFloat\": 1.0,\n \"zeroDouble\": 1.0\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Client uses explicitly provided member values over defaults", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientUsesExplicitlyProvidedMemberValuesOverDefaults", + "method": "POST", + "params": { + "defaults": { + "defaultBlob": "hi", + "defaultBoolean": true, + "defaultByte": 2, + "defaultDocumentBoolean": true, + "defaultDocumentList": [ + "b" + ], + "defaultDocumentMap": { + "name": "Jack" + }, + "defaultDocumentString": "bye", + "defaultDouble": 2.0, + "defaultEnum": "BAR", + "defaultFloat": 2.0, + "defaultIntEnum": 2, + "defaultInteger": 20, + "defaultList": [ + "a" + ], + "defaultLong": 200, + "defaultMap": { + "name": "Jack" + }, + "defaultNullDocument": "notNull", + "defaultShort": 2, + "defaultString": "bye", + "defaultTimestamp": 1, + "emptyBlob": "hi", + "emptyString": "foo", + "falseBoolean": true, + "zeroByte": 1, + "zeroDouble": 1.0, + "zeroFloat": 1.0, + "zeroInteger": 1, + "zeroLong": 1, + "zeroShort": 1 + } + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ], + "uri": "/OperationWithDefaults" + }, + { + "appliesTo": "client", + "body": "{\n \"topLevelDefault\": \"hi\",\n \"otherTopLevelDefault\": 0\n}", + "bodyMediaType": "application/json", + "documentation": "Any time a value is provided for a member in the top level of input, it is used, regardless of if its the default.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientUsesExplicitlyProvidedValuesInTopLevel", + "method": "POST", + "params": { + "otherTopLevelDefault": 0, + "topLevelDefault": "hi" + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ], + "uri": "/OperationWithDefaults" + }, + { + "appliesTo": "client", + "body": "{\n \"clientOptionalDefaults\": {}\n}", + "bodyMediaType": "application/json", + "documentation": "Typically, non top-level members would have defaults filled in, but if they have the clientOptional trait, the defaults should be ignored.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientIgnoresNonTopLevelDefaultsOnMembersWithClientOptional", + "method": "POST", + "params": { + "clientOptionalDefaults": {} + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ], + "uri": "/OperationWithDefaults" + } + ], + "responses": [ + { + "appliesTo": "client", + "body": "{}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Client populates default values when missing in response.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientPopulatesDefaultsValuesWhenMissingInResponse", + "params": { + "defaultBlob": "abc", + "defaultBoolean": true, + "defaultByte": 1, + "defaultDocumentBoolean": true, + "defaultDocumentList": [], + "defaultDocumentMap": {}, + "defaultDocumentString": "hi", + "defaultDouble": 1.0, + "defaultEnum": "FOO", + "defaultFloat": 1.0, + "defaultIntEnum": 1, + "defaultInteger": 10, + "defaultList": [], + "defaultLong": 100, + "defaultMap": {}, + "defaultShort": 1, + "defaultString": "hi", + "defaultTimestamp": 0, + "emptyBlob": "", + "emptyString": "", + "falseBoolean": false, + "zeroByte": 0, + "zeroDouble": 0.0, + "zeroFloat": 0.0, + "zeroInteger": 0, + "zeroLong": 0, + "zeroShort": 0 + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ] + }, + { + "appliesTo": "client", + "body": "{\n \"defaultString\": \"bye\",\n \"defaultBoolean\": false,\n \"defaultList\": [\"a\"],\n \"defaultDocumentMap\": {\"name\": \"Jack\"},\n \"defaultDocumentString\": \"bye\",\n \"defaultDocumentBoolean\": false,\n \"defaultDocumentList\": [\"b\"],\n \"defaultNullDocument\": \"notNull\",\n \"defaultTimestamp\": 2,\n \"defaultBlob\": \"aGk=\",\n \"defaultByte\": 2,\n \"defaultShort\": 2,\n \"defaultInteger\": 20,\n \"defaultLong\": 200,\n \"defaultFloat\": 2.0,\n \"defaultDouble\": 2.0,\n \"defaultMap\": {\"name\": \"Jack\"},\n \"defaultEnum\": \"BAR\",\n \"defaultIntEnum\": 2,\n \"emptyString\": \"foo\",\n \"falseBoolean\": true,\n \"emptyBlob\": \"aGk=\",\n \"zeroByte\": 1,\n \"zeroShort\": 1,\n \"zeroInteger\": 1,\n \"zeroLong\": 1,\n \"zeroFloat\": 1.0,\n \"zeroDouble\": 1.0\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Client ignores default values if member values are present in the response.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientIgnoresDefaultValuesIfMemberValuesArePresentInResponse", + "params": { + "defaultBlob": "hi", + "defaultBoolean": false, + "defaultByte": 2, + "defaultDocumentBoolean": false, + "defaultDocumentList": [ + "b" + ], + "defaultDocumentMap": { + "name": "Jack" + }, + "defaultDocumentString": "bye", + "defaultDouble": 2.0, + "defaultEnum": "BAR", + "defaultFloat": 2.0, + "defaultIntEnum": 2, + "defaultInteger": 20, + "defaultList": [ + "a" + ], + "defaultLong": 200, + "defaultMap": { + "name": "Jack" + }, + "defaultNullDocument": "notNull", + "defaultShort": 2, + "defaultString": "bye", + "defaultTimestamp": 2, + "emptyBlob": "hi", + "emptyString": "foo", + "falseBoolean": true, + "zeroByte": 1, + "zeroDouble": 1.0, + "zeroFloat": 1.0, + "zeroInteger": 1, + "zeroLong": 1, + "zeroShort": 1 + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ] + } + ] + }, + "aws.protocoltests.restjson#OperationWithNestedStructure": { + "requests": [ + { + "appliesTo": "client", + "body": "{\n \"topLevel\": {\n \"dialog\": {\n \"language\": \"en\",\n \"greeting\": \"hi\"\n },\n \"dialogList\": [\n {\n \"greeting\": \"hi\"\n },\n {\n \"greeting\": \"hi\",\n \"farewell\": {\n \"phrase\": \"bye\"\n }\n },\n {\n \"language\": \"it\",\n \"greeting\": \"ciao\",\n \"farewell\": {\n \"phrase\": \"arrivederci\"\n }\n }\n ],\n \"dialogMap\": {\n \"emptyDialog\": {\n \"greeting\": \"hi\"\n },\n \"partialEmptyDialog\": {\n \"language\": \"en\",\n \"greeting\": \"hi\",\n \"farewell\": {\n \"phrase\": \"bye\"\n }\n },\n \"nonEmptyDialog\": {\n \"greeting\": \"konnichiwa\",\n \"farewell\": {\n \"phrase\": \"sayonara\"\n }\n }\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Client populates nested default values when missing.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientPopulatesNestedDefaultValuesWhenMissing", + "method": "POST", + "params": { + "topLevel": { + "dialog": { + "language": "en" + }, + "dialogList": [ + {}, + { + "farewell": {} + }, + { + "farewell": { + "phrase": "arrivederci" + }, + "greeting": "ciao", + "language": "it" + } + ], + "dialogMap": { + "emptyDialog": {}, + "nonEmptyDialog": { + "farewell": { + "phrase": "sayonara" + }, + "greeting": "konnichiwa" + }, + "partialEmptyDialog": { + "farewell": {}, + "language": "en" + } + } + } + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ], + "uri": "/OperationWithNestedStructure" + } + ], + "responses": [ + { + "appliesTo": "client", + "body": "{\n \"dialog\": {\n \"language\": \"en\"\n },\n \"dialogList\": [\n {\n },\n {\n \"farewell\": {}\n },\n {\n \"language\": \"it\",\n \"greeting\": \"ciao\",\n \"farewell\": {\n \"phrase\": \"arrivederci\"\n }\n }\n ],\n \"dialogMap\": {\n \"emptyDialog\": {\n },\n \"partialEmptyDialog\": {\n \"language\": \"en\",\n \"farewell\": {}\n },\n \"nonEmptyDialog\": {\n \"greeting\": \"konnichiwa\",\n \"farewell\": {\n \"phrase\": \"sayonara\"\n }\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Client populates nested default values when missing in response body.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonClientPopulatesNestedDefaultsWhenMissingInResponseBody", + "params": { + "dialog": { + "greeting": "hi", + "language": "en" + }, + "dialogList": [ + { + "greeting": "hi" + }, + { + "farewell": { + "phrase": "bye" + }, + "greeting": "hi" + }, + { + "farewell": { + "phrase": "arrivederci" + }, + "greeting": "ciao", + "language": "it" + } + ], + "dialogMap": { + "emptyDialog": { + "greeting": "hi" + }, + "nonEmptyDialog": { + "farewell": { + "phrase": "sayonara" + }, + "greeting": "konnichiwa" + }, + "partialEmptyDialog": { + "farewell": { + "phrase": "bye" + }, + "greeting": "hi", + "language": "en" + } + } + }, + "protocol": "aws.protocols#restJson1", + "tags": [ + "defaults" + ] + } + ] + }, + "aws.protocoltests.restjson#PostPlayerAction": { + "requests": [ + { + "body": "{\n \"action\": {\n \"quit\": {}\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Unit types in unions are serialized like normal structures in requests.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonInputUnionWithUnitMember", + "method": "POST", + "params": { + "action": { + "quit": {} + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/PostPlayerAction" + } + ], + "responses": [ + { + "body": "{\n \"action\": {\n \"quit\": {}\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Unit types in unions are serialized like normal structures in responses.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonOutputUnionWithUnitMember", + "params": { + "action": { + "quit": {} + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#PostUnionWithJsonName": { + "requests": [ + { + "body": "{\n \"value\": {\n \"FOO\": \"hi\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Tests that jsonName works with union members.", + "headers": { + "Content-Type": "application/json" + }, + "id": "PostUnionWithJsonNameRequest1", + "method": "POST", + "params": { + "value": { + "foo": "hi" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/PostUnionWithJsonName" + }, + { + "body": "{\n \"value\": {\n \"_baz\": \"hi\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Tests that jsonName works with union members.", + "headers": { + "Content-Type": "application/json" + }, + "id": "PostUnionWithJsonNameRequest2", + "method": "POST", + "params": { + "value": { + "baz": "hi" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/PostUnionWithJsonName" + }, + { + "body": "{\n \"value\": {\n \"bar\": \"hi\"\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Tests that jsonName works with union members.", + "headers": { + "Content-Type": "application/json" + }, + "id": "PostUnionWithJsonNameRequest3", + "method": "POST", + "params": { + "value": { + "bar": "hi" + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/PostUnionWithJsonName" + } + ], + "responses": [ + { + "body": "{\n \"value\": {\n \"FOO\": \"hi\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Tests that jsonName works with union members.", + "headers": { + "Content-Type": "application/json" + }, + "id": "PostUnionWithJsonNameResponse1", + "params": { + "value": { + "foo": "hi" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"value\": {\n \"_baz\": \"hi\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Tests that jsonName works with union members.", + "headers": { + "Content-Type": "application/json" + }, + "id": "PostUnionWithJsonNameResponse2", + "params": { + "value": { + "baz": "hi" + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"value\": {\n \"bar\": \"hi\"\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Tests that jsonName works with union members.", + "headers": { + "Content-Type": "application/json" + }, + "id": "PostUnionWithJsonNameResponse3", + "params": { + "value": { + "bar": "hi" + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#PutWithContentEncoding": { + "requests": [ + { + "documentation": "Compression algorithm encoding is appended to the Content-Encoding header.", + "headers": { + "Content-Encoding": "gzip" + }, + "id": "SDKAppliedContentEncoding_restJson1", + "method": "POST", + "params": { + "data": "RjCEL3kBwqPivZUXGiyA5JCujtWgJAkKRlnTEsNYfBRGOS0f7LT6R3bCSOXeJ4auSHzQ4BEZZTklUyj5\n1HEojihShQC2jkQJrNdGOZNSW49yRO0XbnGmeczUHbZqZRelLFKW4xjru9uTuB8lFCtwoGgciFsgqTF8\n5HYcoqINTRxuAwGuRUMoNO473QT0BtCQoKUkAyVaypG0hBZdGNoJhunBfW0d3HWTYlzz9pXElyZhq3C1\n2PDB17GEoOYXmTxDecysmPOdo5z6T0HFhujfeJFIQQ8dirmXcG4F3v0bZdf6AZ3jsiVh6RnEXIPxPbOi\ngIXDWTMUr4Pg3f2LdYCM01eAb2qTdgsEN0MUDhEIfn68I2tnWvcozyUFpg1ez6pyWP8ssWVfFrckREIM\nMb0cTUVqSVSM8bnFiF9SoXM6ZoGMKfX1mT708OYk7SqZ1JlCTkecDJDoR5ED2q2MWKUGR6jjnEV0GtD8\nWJO6AcF0DptY9Hk16Bav3z6c5FeBvrGDrxTFVgRUk8SychzjrcqJ4qskwN8rL3zslC0oqobQRnLFOvwJ\nprSzBIwdH2yAuxokXAdVRa1u9NGNRvfWJfKkwbbVz8yV76RUF9KNhAUmwyYDrLnxNj8ROl8B7dv8Gans\n7Bit52wcdiJyjBW1pAodB7zqqVwtBx5RaSpF7kEMXexYXp9N0J1jlXzdeg5Wgg4pO7TJNr2joiPVAiFf\nefwMMCNBkYx2z7cRxVxCJZMXXzxSKMGgdTN24bJ5UgE0TxyV52RC0wGWG49S1x5jGrvmxKCIgYPs0w3Z\n0I3XcdB0WEj4x4xRztB9Cx2Mc4qFYQdzS9kOioAgNBti1rBySZ8lFZM2zqxvBsJTTJsmcKPr1crqiXjM\noVWdM4ObOO6QA7Pu4c1hT68CrTmbcecjFcxHkgsqdixnFtN6keMGL9Z2YMjZOjYYzbUEwLJqUVWalkIB\nBkgBRqZpzxx5nB5t0qDH35KjsfKM5cinQaFoRq9y9Z82xdCoKZOsUbxZkk1kVmy1jPDCBhkhixkc5PKS\nFoSKTbeK7kuCEZCtR9OfF2k2MqbygGFsFu2sgb1Zn2YdDbaRwRGeaLhswta09UNSMUo8aTixgoYVHxwy\nvraLB6olPSPegeLOnmBeWyKmEfPdbpdGm4ev4vA2AUFuLIeFz0LkCSN0NgQMrr8ALEm1UNpJLReg1ZAX\nzZh7gtQTZUaBVdMJokaJpLk6FPxSA6zkwB5TegSqhrFIsmvpY3VNWmTUq7H0iADdh3dRQ8Is97bTsbwu\nvAEOjh4FQ9wPSFzEtcSJeYQft5GfWYPisDImjjvHVFshFFkNy2nN18pJmhVPoJc456tgbdfEIdGhIADC\n6UPcSSzE1FxlPpILqZrp3i4NvvKoiOa4a8tnALd2XRHHmsvALn2Wmfu07b86gZlu4yOyuUFNoWI6tFvd\nbHnqSJYNQlFESv13gJw609DBzNnrIgBGYBAcDRrIGAnflRKwVDUnDFrUQmE8xNG6jRlyb1p2Y2RrfBtG\ncKqhuGNiT2DfxpY89ektZ98waPhJrFEPJToNH8EADzBorh3T0h4YP1IeLmaI7SOxeuVrk1kjRqMK0rUB\nlUJgJNtCE35jCyoHMwPQlyi78ZaVv8COVQ24zcGpw0MTy6JUsDzAC3jLNY6xCb40SZV9XzG7nWvXA5Ej\nYC1gTXxF4AtFexIdDZ4RJbtYMyXt8LsEJerwwpkfqvDwsiFuqYC6vIn9RoZO5kI0F35XtUITDQYKZ4eq\nWBV0itxTyyR5Rp6g30pZEmEqOusDaIh96CEmHpOBYAQZ7u1QTfzRdysIGMpzbx5gj9Dxm2PO1glWzY7P\nlVqQiBlXSGDOkBkrB6SkiAxknt9zsPdTTsf3r3nid4hdiPrZmGWNgjOO1khSxZSzBdltrCESNnQmlnP5\nZOHA0eSYXwy8j4od5ZmjA3IpFOEPW2MutMbxIbJpg5dIx2x7WxespftenRLgl3CxcpPDcnb9w8LCHBg7\nSEjrEer6Y8wVLFWsQiv6nTdCPZz9cGqwgtCaiHRy8lTWFgdfWd397vw9rduGld3uUFeFRGjYrphqEmHi\nhiG0GhE6wRFVUsGJtvOCYkVREvbEdxPFeJvlAvOcs9HKbtptlTusvYB86vR2bNcIY4f5JZu2X6sGa354\n7LRk0ps2zqYjat3hMR7XDC8KiKceBteFsXoDjfVxTYKelpedTxqWAafrKhaoAVuNM98PSnkuIWGzjSUC\nNsDJTt6vt1D1afBVPWVmnQ7ZQdtEtLIEwAWYjemAztreELIr1E9fPEILm1Ke4KctP9I0I72Dh4eylNZD\n0DEr2Hg7cWFckuZ0Av5d0IPRARXikEGDHl8uh12TXL9v2Uh0ZVSJMEYvxGSbZvkWz8TjWSk3hKA2a7GL\nJm3Ho7e1C34gE1XRGcEthxvURxt4OKBqN3ZNaMIuDTWinoQAutMcUqtm4MoL7RGPiCHUrvTwQPSirsmA\nQmOEu8nOpnP77Fivh9jLGx5ta7nL6jrsWUsBqiN1lzpdPYLRR4mUIAj6sNWiDEk4pkbHSMEcqbWw6Zl7\npsEyPDHalCNhWMA3RSK3skURzQDZ0oBV5W7vjVIZ4d3uCKsk6zrzEI9u5mx7p9RdNKodXfzqYt0ULdtc\n3RW0hIfw2KvrO3BD2QrtgAkfrFBGVvlJSUoh0MvLz8DeXxfuiuq9Ttu7wvsqVI4Piah6WNEXtHHGPJO3\nGhc75Bnv2To4VS2v8rmyKAPIIVTuYBHZN6sZ4FhFzbrslCIdk0eadaU60naqiNWU3CsxplIYGyeThmJ7\n9u4h6Y2OmiPZjFPS2bAzwgAozYTVefII9aEaWZ0hxHZeu1FW7r79dkdO73ZqRfas9u8Z7LLBPCw5pV0F\n5I0pHDgNb6MogoxF4NZJfVtIX1vCHhhVLrXjrYNJU2fD9Fw8kT8Ie2HDBJnqAvYKmryQ1r9ulo3Me3rH\nq9s2Y5uCDxu9iQNhnpwIm57WYGFeqd2fnQeY2IziD3Jgx0KSrmOH0jgi0RwJyfGXaORPq3bQQqljuACo\nkO6io9t5VI8PbNxSHTRbtYiPciUslbT0g7SpCLrRPOBRJ4DDk56pjghpeoUagJ5xJ4wjBzBuXnAGkNnP\nTfpiuz2r3oSBAi8sB9wiYK2z9sp4gZyQsqdVNzAEgKatOxBRBmJCBYpjO98ZQrF83XApPpfFg0ujB2PW\n1iYF9NkgwIKB5oB6KVTOmSKJk11mVermPgeugHbzdd2zUP6fP8fWbhseqk2t8ahGvqjs2CDHFIWXl5jc\nfCknbykE3ANt7lnAfJQ2ddduLGiqrX4HWx6jcWw08Es6BkleO0IDbaWrb95d5isvFlzJsf0TyDIXF4uq\nbBDCi0XPWqtRJ2iqmnJa2GbBe9GmAOWMkBFSilMyC4sR395WSDpD56fx0NGoU6cHrRu9xF2Bgh7RGSfl\nch2GXEeE02fDpSHFNvJBlOEqqfkIX6oCa6KY9NThqeIjYsT184XR2ZI7akXRaw1gMOGpk4FmUxk6WIuX\n4ei1SLQgSdl7OEdRtJklZ76eFrMbkJQ2TDhu8f7mVuiy53GUMIvCrP9xYGZGmCIDm2e4U2BDi3F7C5xK\n3bDZXwlQp6z4BSqTy2OVEWxXUJfjPMOL5Mc7AvDeKtxAS73pVIv0HgHIa4NBAdC7uLG0zXuu1FF6z2XY\nyUhk03fMZhYe7vVxsul3WE7U01fuN8z2y0eKwBW1RFBE1eKIaR9Y01sIWQWbSrfHfDrdZiElhmhHehfs\n0EfrR4sLYdQshJuvhTeKGJDaEhtPQwwJ9mUYGtuCL9RozWx1XI4bHNlzBTW0BVokYiJGlPe7wdxNzJD7\nJgS7Lwv6jGKngVf86imGZyzqwiteWFPdNUoWdTvUPSMO5xIUK9mo5QpwbBOAmyYzVq42o3Qs90N9khEV\nU36LB99fw8PtGHH5wsCHshfauwnNPj0blGXzke0kQ4JNCVH7Jtn0Y0aeejkSxFtwtxoYs6zHl1Lxxpsd\nsw5vBy49CEtoltDW367lVAwDjWdx20msGB7qJCkEDrzu7EXSO22782QX9NBRcN9ppX0C25I0FMA4Wnhz\n9zIpiXRrsTH35jzM8Cjt4EVLGNU3O0HuEvAer3cENnMJtngdrT86ox3fihMQbiuy4Bh4DEcP5in2VjbT\n3qbnoCNvOi8Fmmf7KlGlWAOceL5OHVE5lljjQEMzEQOCEgrk5mDKgwSBJQBNauIDSC1a5iEQjB8Xxp4C\nqeKyyWY9IOntNrtU5ny4lNprHJd36dKFeBLKcGCOvgHBXdOZloMF0YTRExw7hreEO9IoTGVHJ4teWsNr\nHdtagUHjkeZkdMMfnUGNv5aBNtFMqhcZH6EitEa9lGPkKBbJpoom3u8D8EHSIF1H5EZqqx9TLY5hWAIG\nPwJ4qwkpCGw5rCLVrjw7ARKukIFzNULANqjHUMcJ002TlUosJM4xJ4aAgckpLVGOGuPDhGAAexEcQmbg\nUsZdmqQrtuVUyyLteLbLbqtR6CTlcAIwY3xyMCmPgyefE0FEUODBoxQtRUuYTL9RC5o1sYb2PvcxUQfb\niJFi2CAl99pAzcckU2qVCxniARslIxM5pmMRGsQX9ZzYAfZrbg6ce6S74I8UMlgRQ2QVyvUjKKOE6IrJ\nLng370emHfe5m6LZULD5YiZutkD5ipjL2Bz77DvTE5kNPUhuoKBcTJcUgytfXAKUTWOcRKNlq0GImrxM\nJfr7AWbLFFNKGLeTrVDBwpcokJCv0zcOKWe8fd2xkeXkZTdmM66IgM27cyYmtQ6YF26Kd0qrWJeVZJV9\n3fyLYYvKN5csbRY2BHoYE5ERARRW65IrpkXMf48OrCXMtDIP0Z7wxI9DiTeKKeH4uuguhCJnwzR3WxLA\nVU6eBJEd7ZjS6JA83w7decq8uDI7LGKjcz1FySp3B7fE9DkHRGXxbsL7Fjar6vW2mAv8CuvI20B6jctp\n2yLDs24sPfB3sSxrrlhbuT1m6DZqiN0dl6umKx7NGZhmOTVGr20jfcxhqPQwTJfd7kel4rvxip4BqkvT\n7STy8knJ2BXGyJeNgwo1PXUZRDVy0LCTsSF1RFuRZe8cktHl9lgw8ntdPn1pVFL0MwJkJfdXBNUp5gNv\n50FTkrpo1t6wq4CVbcfj2XOrOzvBUzNH26sXGABI1gGxCdp2jEZrHgqQaWIaTJVTuguZhxqDvdYsrwFW\nYN58uuNcKHIrGdRSigyZInwQDYk0pjcqdSeU0WVU3Y9htzZBR7XRaCJr5YTZvq7fwermb5tuwb37lPLq\nB2IGg0iftkVbXaSyfCwVaRbfLBb88so0QqpmJGirFu8FcDiXOV1zTr8yW9XLdYQuUjh43xrXLdgsuYff\nCagInUk1eU1aLjVZoJRsNmStmOEpAqlYMwTvx7w6j2f421Cxr5cNZBIVlAxlXN2QiDqJ9v3sHhHkTanc\nlQuH8ptUyX8qncpBuXXBn7cSez9N0EoxCBl1GHUagbjstgJo4gzLvTmVIY6MiWYOBitzNUHfyqKwtKUr\nVoSCdZcGeA9lHUPA7PUprRRaT3m1hGKPyshtVS2ikG48w3oVerln1N1qGdtz46gZCrndw3LZ1B362RfW\nzDPuXbpsyLsRMTt1Rz1oKHRXp3iE41hkhQH6pxlvyCW2INnHt5XU8zRamOB3oW0udOhMpQFDjRkOcy06\nb4t0QTHvoRqmBna3WXzIMZyeK3GChF5eF8oDXRbjhk7BB6YKCgqwWUzEJ5K47HMSlhFkBUjaPRjdGM0z\nzOMwhW6b1NvSwP7XM1P5yi1oPvOspts1vr29SXqrMMrBhVogeodWyd69NqrO4jkyBxKmlXifoTowpfiY\n2cUCE0XMZqxUN39LCP09JqZifaEcBEo3mgtm1tWu5QR2GNq7UyQf4RIPSDOpDCAtwoPhRgdT1lJdcj4U\nlnH0wrJ8Uwu7c08L7ErnIrDATqCrOjpSbzGP1xHENABYONC4TknFPrJ8pe40A8fzGT0qBw9mAM1SKcHO\nfoiLcMC9AjHTqJzDG3xplSLPG9or2rMeq7Fzp9r0y7uJRMxgg51EbjfvYlH466A3ggvL2WQlDXjJqPW3\nBJGWAWDNN9LK8f46bADKPxakpkx23S9O47rGSXfDhVSIZsDympxWX1UOzWwMZRHkofVeKqizgbKkGgUT\nWykE9gRoRAOd9wfHZDYKa9i0LaPDiaUMvnU1gdBIqIoiVsdJ9swX47oxvMtOxtcS0zlD6llDkBuIiU5g\nPwRCYmtkkb25c8iRJXwGFPjI1wJ34I1z1ENicPdosPiUe9ZC2jnXIKzEdv01x2ER7DNDF3yxOwOhxNxI\nGqsmC92j25UQQFu9ZstOZ28AoCkuOYs0Uycm5u8jR1T39dMBwrko09rC65ENLnsxM8oebmyFCPiGJ1ED\n5Xqc9qZ237f1OnETAoEOwqUSvrdPTv56U7hV91EMTyC812MLQpr2710E3VVpsUCUMNhIxdt7UXZ1UNFb\njgzpZLXnf4DHrv6B7kq6UI50KMxcw1HZE2GpODfUTzNFLaqdrvzxKe5eUWdcojBaRbD4fFdVYJTElYDH\nNNVh6ofkoeWcs9CWGFmSBe0T4K8phFeygQg0prKMELNEy6qENzVtG9ZDcqj3a7L6ZLtvq50anWp7fAVu\nfwz55g4iM2Z2fA0pnwHDL7tt67zTxGITvsnJsZSpeq1EQsZcwtkBV9liu7Rl7jiVT1IIRtchB8TsTiaA\nwVHIQQ9RIOTiPQdKNqi1kC9iGlUqWK93gblNWlBw1eYB9Wk8FQogutwTf0caNMx8D4nPbANcmOOlskIy\nzALh15OlTrWnhP95rf08AN2J026zDE2DUF9k0eCevYBQIDjqKNW4XCZnjbHoIcKzbY5VzPbMs3ZyMz8K\nSucBmgPg6wrSK5ykbkapS5vuqvXc9GbjQJ8bPNzoxoWGyjbZvDs2OBrIqBmcQb2DLJ8v38McQ4mC4UsS\njf4PyfSCtpk274QZjvLCZbLiCBxQegk7jUU0NmTFJAcYCxd9xMWdlFkiszcltT2YzwuFFz7iA6aa4n5L\nHpBNfUA01GcAi1aCMYhmooS4zSlYcSOZkovMz36U3Fd9WtqIEOJLi7HMgHQDgNMdK6DTzAdHQtxerxVF\nHJnPrfNVG7270r3bp0bPnLNYLhObbAn6zqSAUeLtI2Y4KJDjBKCAh2vvYGbu0e2REYJWRj7MkGevsSSy\nb1kCXLt6tKGWAb7lt5c0xyJgUIJW7pdtnwgT0ZCa24BecCAwNnG5U2EwQbcjZGsFxqNGfaemd3oFEhES\nBaE0Fxms9UKTnMafu8wvZ2xymMrUduuRzOjDeX7oD5YsLC88V8CGMLxbbxIpt94KGykbr6e7L0R4oZl1\ntKMgFwQ2p9Txdbp0Y293LcsJymKizqI0F2xEp7y4SmWOJqHZtsbz80wVV9nv41CvtfxuSoGZJ5cNB7pI\nBgzNcQCeH3Jt0RaGGwboxxpuFbzilmkMFXxJm87tD4WNgu01nHfGCKeQcySEBZpVfJgi6sDFJ8uWnvKm\n9mPLHurtWzEfKqUEa1iC71bXjw5wrvhv9BYW8JSUELHmDquftQyKdq0DZXhULMHGQLf4e95WIaoA14LL\nbThz77kuhKULPTu2MNrBUKGorurhGugo5gs4ZUezSsUOe3KxYdrFMdGgny1GgTxMSMTp2RAZytKjv4kQ\nVx7XgzvpQLIbDjUPAkJv6lScwIRq1W3Ne0Rh0V6Bmn6U5uIuWnJjULmbaQiSODj3z0mAZvak0mSWIGwT\nTX83HztcC4W7e1f6a1thmcc5K61Icehla2hBELWPpixTkyC4eEVmk9Rq0m0ZXtx0JX2ZQXqXDEyePyMe\nJ70sdSzXk72zusqhY4yuOMGgbYNHqxOToK6NxujR7e4dV3Wk5JnSUthym8scjcPeCiKDNY4cHfTMnDXJ\n9zLVy01LtNKYpJ1s8FxVxigmxQNKEbIamxhx6yqwGC4aiISVOOUEjvNOdaUfXfUsE6jEwtwxyGxjlRK1\ncLyxXttq4QWN6PehgHv7jXykzPjInbEysebFvvPOOMdunmJvcCNMSvjUda8fL6xfGo0FDrLg8XZipd6S\noPVdYtyIM1Dg40KbBA3JuumPYtXuJaHrZnjZmdnM5OVo4ZNxktfCVT0c6bnD4bAeyn4bYt1ZPaX6hQHh\nJtvNYfpD0ONYlmqKuToQAMlz52Fh6bj45EbX89L5eLlSpWeyBlGotzriB0EPlclrGi5l2B5oPb1aB1ag\nyyYuu44l0F1oOVYnBIZsxIsHVITxi9lEuVPFkWASOUNuVQXfM4n5hxWR9qtuKnIcPsvbJsv1U10XlKh3\nKisqPhHU15xrCLr5gwFxPUKiNTLUBrkzgBOHXPVsHcLCiSD0YU56TRGfvEom43TWUKPPfl9Z54tgVQuT\njCRlaljAzeniQIcbbHZnn3f0HxbDG3DFYqWSxNrXabHhRsIOhhUHSPENyhGSTVO5t0XX5CdMspJPCd02\n3Oqv32ccbUK4O3YH6LEvp0WO3kSl5n50odVkI9B0i0iq4UPFGMkM8bEQJbgJoOH71P10vtdevJFQE4g2\nyhimiM53ZJRWgSZveHtENZc0Gjo0F9eioak9BnPpY1QxAFPC817svuhEstcU69bLCA4D1rO5R8AuIIBq\nyQJcifFLvbpAEYTLKJqysZrU8EEl3TSdC13A9hZvk4NC8VGEDAxcNrKw313dZp17kZPO5HSd1y6sljAW\nA9M1d6FMYV5SlBWf3WZNCUPS7qKNlda2YBsC6IUVB363f5RLGQOQHwbaijBSRCkrVoRxBHtc0Bd5J9V9\nP5uMTXkpZOxRcCQvImGgcmGuxxLb5zTqfS2xu7v3Sf3IIesSt9tVzcEcdbEvLGVJkLk4mb3G30DbIbri\nPZ09JkweDvMaQ3bxT2nfkz3Ilihkw9jqikkCCCz7E8h6z6KbhQErEW9VzJZzMCgJsyPjFam6iNwpe07S\nhyOvNVw2t9wpzL5xM11DvVzQwDaWEytNRHzDBs4KwEtpI2IpjUyVZHSwA0UGqqkzoCgrJFlNOvPlXqcS\nIcREouUIBmuttkrhPWJtSxOOgpsdvBR3kTOzAXNzSKxoaBAb0c5SDMUc6FIyGA8x5wg5DkUgjFUUodEt\nOYaB2VHVePW9mxHeBTdKWLzJow4ZZvjnoBuVigXljKCNh137ckV2y3Yg3Xi4UzJEI2V5Rw9AfnMs7xUw\nVHOFCg189maD3bmZAe7b4eaGZhyy4HVKjqCXmIH7vsEjRvbnfB0SQxxpuqBDJbHNCtW4vM643ZQQBVPP\na7oXSQIq9w2dHp0A7dtkocCZdQp9FKR9XdJAFIbVSHzIF1ZogeZlc0pXuNE0tagvD57xwDRFkAuoQyMu\nYDdZasXrpSmEE5UjHVkyYsISn8QsfXurzDybX468aoRoks654jjmRY5zi1oB8TcMdC2c3sicNaqfeuhd\nH1nPX7l4RpdqWMR7gGx9slXtG8S3KxpOi4qCD7yg3saD66nun4dzksQURoTUdXyrJR5UpHsfIlTF1aJa\nMdXyQtQnrkl00TeghQd00rRFZsCnhi0qrCSKiBfB2EVrd9RPpbgwJGZHuIQecdBmNetc2ylSEClqVBPR\nGOPPIxrnswEZjmnS0jxKW9VSM1QVxSPJnPFswCqT95SoKD6CP4xdX28WIUGiNaIKodXXJHEIsXBCxLsr\nPwWPCtoplC6hhpKmW5dQo92iCTyY2KioKzO8XR6FKm6qonMKVEwQNtlYE9c97KMtEnp25VOdMP46SQXS\nYsSVp7vm8LP87VYI8SOKcW3s2oedYFtt45rvDzoTF0GmS6wELQ9uo98HhjQAI1Dt91cgjJOwygNmLoZE\nX5K2zQiNA163uMCl5xzaBqY4YTL0wgALg3IFdYSp0RFYLWdt6IxoGI1tnoxcjlUEPo5eGIc3mS3SmaLn\nOdumfUQQ4Jgmgaa5anUVQsfBDrlAN5oaX7O0JO71SSPSWiHBsT9WIPy2J1Cace9ZZLRxblFPSXcvsuHh\nhvnhWQltEDAe7MgvkFQ8lGVFa8jhzijoF9kLmMhMILSzYnfXnZPNP7TlAAwlLHK1RqlpHskJqb6CPpGP\nQvOAhEMsM3zJ2KejZx0esxkjxA0ZufVvGAMN3vTUMplQaF4RiQkp9fzBXf3CMk01dWjOMMIEXTeKzIQe\nEcffzjixWU9FpAyGp2rVl4ETRgqljOGw4UgK31r0ZIEGnH0xGz1FtbW1OcQM008JVujRqulCucEMmntr\n" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/requestcompression/putcontentwithencoding" + }, + { + "documentation": "Compression algorithm encoding is appended to the Content-Encoding header, and the\nuser-provided content-encoding is in the Content-Encoding header before the\nrequest compression encoding from the HTTP binding.\n", + "headers": { + "Content-Encoding": "custom, gzip" + }, + "id": "SDKAppendedGzipAfterProvidedEncoding_restJson1", + "method": "POST", + "params": { + "data": "RjCEL3kBwqPivZUXGiyA5JCujtWgJAkKRlnTEsNYfBRGOS0f7LT6R3bCSOXeJ4auSHzQ4BEZZTklUyj5\n1HEojihShQC2jkQJrNdGOZNSW49yRO0XbnGmeczUHbZqZRelLFKW4xjru9uTuB8lFCtwoGgciFsgqTF8\n5HYcoqINTRxuAwGuRUMoNO473QT0BtCQoKUkAyVaypG0hBZdGNoJhunBfW0d3HWTYlzz9pXElyZhq3C1\n2PDB17GEoOYXmTxDecysmPOdo5z6T0HFhujfeJFIQQ8dirmXcG4F3v0bZdf6AZ3jsiVh6RnEXIPxPbOi\ngIXDWTMUr4Pg3f2LdYCM01eAb2qTdgsEN0MUDhEIfn68I2tnWvcozyUFpg1ez6pyWP8ssWVfFrckREIM\nMb0cTUVqSVSM8bnFiF9SoXM6ZoGMKfX1mT708OYk7SqZ1JlCTkecDJDoR5ED2q2MWKUGR6jjnEV0GtD8\nWJO6AcF0DptY9Hk16Bav3z6c5FeBvrGDrxTFVgRUk8SychzjrcqJ4qskwN8rL3zslC0oqobQRnLFOvwJ\nprSzBIwdH2yAuxokXAdVRa1u9NGNRvfWJfKkwbbVz8yV76RUF9KNhAUmwyYDrLnxNj8ROl8B7dv8Gans\n7Bit52wcdiJyjBW1pAodB7zqqVwtBx5RaSpF7kEMXexYXp9N0J1jlXzdeg5Wgg4pO7TJNr2joiPVAiFf\nefwMMCNBkYx2z7cRxVxCJZMXXzxSKMGgdTN24bJ5UgE0TxyV52RC0wGWG49S1x5jGrvmxKCIgYPs0w3Z\n0I3XcdB0WEj4x4xRztB9Cx2Mc4qFYQdzS9kOioAgNBti1rBySZ8lFZM2zqxvBsJTTJsmcKPr1crqiXjM\noVWdM4ObOO6QA7Pu4c1hT68CrTmbcecjFcxHkgsqdixnFtN6keMGL9Z2YMjZOjYYzbUEwLJqUVWalkIB\nBkgBRqZpzxx5nB5t0qDH35KjsfKM5cinQaFoRq9y9Z82xdCoKZOsUbxZkk1kVmy1jPDCBhkhixkc5PKS\nFoSKTbeK7kuCEZCtR9OfF2k2MqbygGFsFu2sgb1Zn2YdDbaRwRGeaLhswta09UNSMUo8aTixgoYVHxwy\nvraLB6olPSPegeLOnmBeWyKmEfPdbpdGm4ev4vA2AUFuLIeFz0LkCSN0NgQMrr8ALEm1UNpJLReg1ZAX\nzZh7gtQTZUaBVdMJokaJpLk6FPxSA6zkwB5TegSqhrFIsmvpY3VNWmTUq7H0iADdh3dRQ8Is97bTsbwu\nvAEOjh4FQ9wPSFzEtcSJeYQft5GfWYPisDImjjvHVFshFFkNy2nN18pJmhVPoJc456tgbdfEIdGhIADC\n6UPcSSzE1FxlPpILqZrp3i4NvvKoiOa4a8tnALd2XRHHmsvALn2Wmfu07b86gZlu4yOyuUFNoWI6tFvd\nbHnqSJYNQlFESv13gJw609DBzNnrIgBGYBAcDRrIGAnflRKwVDUnDFrUQmE8xNG6jRlyb1p2Y2RrfBtG\ncKqhuGNiT2DfxpY89ektZ98waPhJrFEPJToNH8EADzBorh3T0h4YP1IeLmaI7SOxeuVrk1kjRqMK0rUB\nlUJgJNtCE35jCyoHMwPQlyi78ZaVv8COVQ24zcGpw0MTy6JUsDzAC3jLNY6xCb40SZV9XzG7nWvXA5Ej\nYC1gTXxF4AtFexIdDZ4RJbtYMyXt8LsEJerwwpkfqvDwsiFuqYC6vIn9RoZO5kI0F35XtUITDQYKZ4eq\nWBV0itxTyyR5Rp6g30pZEmEqOusDaIh96CEmHpOBYAQZ7u1QTfzRdysIGMpzbx5gj9Dxm2PO1glWzY7P\nlVqQiBlXSGDOkBkrB6SkiAxknt9zsPdTTsf3r3nid4hdiPrZmGWNgjOO1khSxZSzBdltrCESNnQmlnP5\nZOHA0eSYXwy8j4od5ZmjA3IpFOEPW2MutMbxIbJpg5dIx2x7WxespftenRLgl3CxcpPDcnb9w8LCHBg7\nSEjrEer6Y8wVLFWsQiv6nTdCPZz9cGqwgtCaiHRy8lTWFgdfWd397vw9rduGld3uUFeFRGjYrphqEmHi\nhiG0GhE6wRFVUsGJtvOCYkVREvbEdxPFeJvlAvOcs9HKbtptlTusvYB86vR2bNcIY4f5JZu2X6sGa354\n7LRk0ps2zqYjat3hMR7XDC8KiKceBteFsXoDjfVxTYKelpedTxqWAafrKhaoAVuNM98PSnkuIWGzjSUC\nNsDJTt6vt1D1afBVPWVmnQ7ZQdtEtLIEwAWYjemAztreELIr1E9fPEILm1Ke4KctP9I0I72Dh4eylNZD\n0DEr2Hg7cWFckuZ0Av5d0IPRARXikEGDHl8uh12TXL9v2Uh0ZVSJMEYvxGSbZvkWz8TjWSk3hKA2a7GL\nJm3Ho7e1C34gE1XRGcEthxvURxt4OKBqN3ZNaMIuDTWinoQAutMcUqtm4MoL7RGPiCHUrvTwQPSirsmA\nQmOEu8nOpnP77Fivh9jLGx5ta7nL6jrsWUsBqiN1lzpdPYLRR4mUIAj6sNWiDEk4pkbHSMEcqbWw6Zl7\npsEyPDHalCNhWMA3RSK3skURzQDZ0oBV5W7vjVIZ4d3uCKsk6zrzEI9u5mx7p9RdNKodXfzqYt0ULdtc\n3RW0hIfw2KvrO3BD2QrtgAkfrFBGVvlJSUoh0MvLz8DeXxfuiuq9Ttu7wvsqVI4Piah6WNEXtHHGPJO3\nGhc75Bnv2To4VS2v8rmyKAPIIVTuYBHZN6sZ4FhFzbrslCIdk0eadaU60naqiNWU3CsxplIYGyeThmJ7\n9u4h6Y2OmiPZjFPS2bAzwgAozYTVefII9aEaWZ0hxHZeu1FW7r79dkdO73ZqRfas9u8Z7LLBPCw5pV0F\n5I0pHDgNb6MogoxF4NZJfVtIX1vCHhhVLrXjrYNJU2fD9Fw8kT8Ie2HDBJnqAvYKmryQ1r9ulo3Me3rH\nq9s2Y5uCDxu9iQNhnpwIm57WYGFeqd2fnQeY2IziD3Jgx0KSrmOH0jgi0RwJyfGXaORPq3bQQqljuACo\nkO6io9t5VI8PbNxSHTRbtYiPciUslbT0g7SpCLrRPOBRJ4DDk56pjghpeoUagJ5xJ4wjBzBuXnAGkNnP\nTfpiuz2r3oSBAi8sB9wiYK2z9sp4gZyQsqdVNzAEgKatOxBRBmJCBYpjO98ZQrF83XApPpfFg0ujB2PW\n1iYF9NkgwIKB5oB6KVTOmSKJk11mVermPgeugHbzdd2zUP6fP8fWbhseqk2t8ahGvqjs2CDHFIWXl5jc\nfCknbykE3ANt7lnAfJQ2ddduLGiqrX4HWx6jcWw08Es6BkleO0IDbaWrb95d5isvFlzJsf0TyDIXF4uq\nbBDCi0XPWqtRJ2iqmnJa2GbBe9GmAOWMkBFSilMyC4sR395WSDpD56fx0NGoU6cHrRu9xF2Bgh7RGSfl\nch2GXEeE02fDpSHFNvJBlOEqqfkIX6oCa6KY9NThqeIjYsT184XR2ZI7akXRaw1gMOGpk4FmUxk6WIuX\n4ei1SLQgSdl7OEdRtJklZ76eFrMbkJQ2TDhu8f7mVuiy53GUMIvCrP9xYGZGmCIDm2e4U2BDi3F7C5xK\n3bDZXwlQp6z4BSqTy2OVEWxXUJfjPMOL5Mc7AvDeKtxAS73pVIv0HgHIa4NBAdC7uLG0zXuu1FF6z2XY\nyUhk03fMZhYe7vVxsul3WE7U01fuN8z2y0eKwBW1RFBE1eKIaR9Y01sIWQWbSrfHfDrdZiElhmhHehfs\n0EfrR4sLYdQshJuvhTeKGJDaEhtPQwwJ9mUYGtuCL9RozWx1XI4bHNlzBTW0BVokYiJGlPe7wdxNzJD7\nJgS7Lwv6jGKngVf86imGZyzqwiteWFPdNUoWdTvUPSMO5xIUK9mo5QpwbBOAmyYzVq42o3Qs90N9khEV\nU36LB99fw8PtGHH5wsCHshfauwnNPj0blGXzke0kQ4JNCVH7Jtn0Y0aeejkSxFtwtxoYs6zHl1Lxxpsd\nsw5vBy49CEtoltDW367lVAwDjWdx20msGB7qJCkEDrzu7EXSO22782QX9NBRcN9ppX0C25I0FMA4Wnhz\n9zIpiXRrsTH35jzM8Cjt4EVLGNU3O0HuEvAer3cENnMJtngdrT86ox3fihMQbiuy4Bh4DEcP5in2VjbT\n3qbnoCNvOi8Fmmf7KlGlWAOceL5OHVE5lljjQEMzEQOCEgrk5mDKgwSBJQBNauIDSC1a5iEQjB8Xxp4C\nqeKyyWY9IOntNrtU5ny4lNprHJd36dKFeBLKcGCOvgHBXdOZloMF0YTRExw7hreEO9IoTGVHJ4teWsNr\nHdtagUHjkeZkdMMfnUGNv5aBNtFMqhcZH6EitEa9lGPkKBbJpoom3u8D8EHSIF1H5EZqqx9TLY5hWAIG\nPwJ4qwkpCGw5rCLVrjw7ARKukIFzNULANqjHUMcJ002TlUosJM4xJ4aAgckpLVGOGuPDhGAAexEcQmbg\nUsZdmqQrtuVUyyLteLbLbqtR6CTlcAIwY3xyMCmPgyefE0FEUODBoxQtRUuYTL9RC5o1sYb2PvcxUQfb\niJFi2CAl99pAzcckU2qVCxniARslIxM5pmMRGsQX9ZzYAfZrbg6ce6S74I8UMlgRQ2QVyvUjKKOE6IrJ\nLng370emHfe5m6LZULD5YiZutkD5ipjL2Bz77DvTE5kNPUhuoKBcTJcUgytfXAKUTWOcRKNlq0GImrxM\nJfr7AWbLFFNKGLeTrVDBwpcokJCv0zcOKWe8fd2xkeXkZTdmM66IgM27cyYmtQ6YF26Kd0qrWJeVZJV9\n3fyLYYvKN5csbRY2BHoYE5ERARRW65IrpkXMf48OrCXMtDIP0Z7wxI9DiTeKKeH4uuguhCJnwzR3WxLA\nVU6eBJEd7ZjS6JA83w7decq8uDI7LGKjcz1FySp3B7fE9DkHRGXxbsL7Fjar6vW2mAv8CuvI20B6jctp\n2yLDs24sPfB3sSxrrlhbuT1m6DZqiN0dl6umKx7NGZhmOTVGr20jfcxhqPQwTJfd7kel4rvxip4BqkvT\n7STy8knJ2BXGyJeNgwo1PXUZRDVy0LCTsSF1RFuRZe8cktHl9lgw8ntdPn1pVFL0MwJkJfdXBNUp5gNv\n50FTkrpo1t6wq4CVbcfj2XOrOzvBUzNH26sXGABI1gGxCdp2jEZrHgqQaWIaTJVTuguZhxqDvdYsrwFW\nYN58uuNcKHIrGdRSigyZInwQDYk0pjcqdSeU0WVU3Y9htzZBR7XRaCJr5YTZvq7fwermb5tuwb37lPLq\nB2IGg0iftkVbXaSyfCwVaRbfLBb88so0QqpmJGirFu8FcDiXOV1zTr8yW9XLdYQuUjh43xrXLdgsuYff\nCagInUk1eU1aLjVZoJRsNmStmOEpAqlYMwTvx7w6j2f421Cxr5cNZBIVlAxlXN2QiDqJ9v3sHhHkTanc\nlQuH8ptUyX8qncpBuXXBn7cSez9N0EoxCBl1GHUagbjstgJo4gzLvTmVIY6MiWYOBitzNUHfyqKwtKUr\nVoSCdZcGeA9lHUPA7PUprRRaT3m1hGKPyshtVS2ikG48w3oVerln1N1qGdtz46gZCrndw3LZ1B362RfW\nzDPuXbpsyLsRMTt1Rz1oKHRXp3iE41hkhQH6pxlvyCW2INnHt5XU8zRamOB3oW0udOhMpQFDjRkOcy06\nb4t0QTHvoRqmBna3WXzIMZyeK3GChF5eF8oDXRbjhk7BB6YKCgqwWUzEJ5K47HMSlhFkBUjaPRjdGM0z\nzOMwhW6b1NvSwP7XM1P5yi1oPvOspts1vr29SXqrMMrBhVogeodWyd69NqrO4jkyBxKmlXifoTowpfiY\n2cUCE0XMZqxUN39LCP09JqZifaEcBEo3mgtm1tWu5QR2GNq7UyQf4RIPSDOpDCAtwoPhRgdT1lJdcj4U\nlnH0wrJ8Uwu7c08L7ErnIrDATqCrOjpSbzGP1xHENABYONC4TknFPrJ8pe40A8fzGT0qBw9mAM1SKcHO\nfoiLcMC9AjHTqJzDG3xplSLPG9or2rMeq7Fzp9r0y7uJRMxgg51EbjfvYlH466A3ggvL2WQlDXjJqPW3\nBJGWAWDNN9LK8f46bADKPxakpkx23S9O47rGSXfDhVSIZsDympxWX1UOzWwMZRHkofVeKqizgbKkGgUT\nWykE9gRoRAOd9wfHZDYKa9i0LaPDiaUMvnU1gdBIqIoiVsdJ9swX47oxvMtOxtcS0zlD6llDkBuIiU5g\nPwRCYmtkkb25c8iRJXwGFPjI1wJ34I1z1ENicPdosPiUe9ZC2jnXIKzEdv01x2ER7DNDF3yxOwOhxNxI\nGqsmC92j25UQQFu9ZstOZ28AoCkuOYs0Uycm5u8jR1T39dMBwrko09rC65ENLnsxM8oebmyFCPiGJ1ED\n5Xqc9qZ237f1OnETAoEOwqUSvrdPTv56U7hV91EMTyC812MLQpr2710E3VVpsUCUMNhIxdt7UXZ1UNFb\njgzpZLXnf4DHrv6B7kq6UI50KMxcw1HZE2GpODfUTzNFLaqdrvzxKe5eUWdcojBaRbD4fFdVYJTElYDH\nNNVh6ofkoeWcs9CWGFmSBe0T4K8phFeygQg0prKMELNEy6qENzVtG9ZDcqj3a7L6ZLtvq50anWp7fAVu\nfwz55g4iM2Z2fA0pnwHDL7tt67zTxGITvsnJsZSpeq1EQsZcwtkBV9liu7Rl7jiVT1IIRtchB8TsTiaA\nwVHIQQ9RIOTiPQdKNqi1kC9iGlUqWK93gblNWlBw1eYB9Wk8FQogutwTf0caNMx8D4nPbANcmOOlskIy\nzALh15OlTrWnhP95rf08AN2J026zDE2DUF9k0eCevYBQIDjqKNW4XCZnjbHoIcKzbY5VzPbMs3ZyMz8K\nSucBmgPg6wrSK5ykbkapS5vuqvXc9GbjQJ8bPNzoxoWGyjbZvDs2OBrIqBmcQb2DLJ8v38McQ4mC4UsS\njf4PyfSCtpk274QZjvLCZbLiCBxQegk7jUU0NmTFJAcYCxd9xMWdlFkiszcltT2YzwuFFz7iA6aa4n5L\nHpBNfUA01GcAi1aCMYhmooS4zSlYcSOZkovMz36U3Fd9WtqIEOJLi7HMgHQDgNMdK6DTzAdHQtxerxVF\nHJnPrfNVG7270r3bp0bPnLNYLhObbAn6zqSAUeLtI2Y4KJDjBKCAh2vvYGbu0e2REYJWRj7MkGevsSSy\nb1kCXLt6tKGWAb7lt5c0xyJgUIJW7pdtnwgT0ZCa24BecCAwNnG5U2EwQbcjZGsFxqNGfaemd3oFEhES\nBaE0Fxms9UKTnMafu8wvZ2xymMrUduuRzOjDeX7oD5YsLC88V8CGMLxbbxIpt94KGykbr6e7L0R4oZl1\ntKMgFwQ2p9Txdbp0Y293LcsJymKizqI0F2xEp7y4SmWOJqHZtsbz80wVV9nv41CvtfxuSoGZJ5cNB7pI\nBgzNcQCeH3Jt0RaGGwboxxpuFbzilmkMFXxJm87tD4WNgu01nHfGCKeQcySEBZpVfJgi6sDFJ8uWnvKm\n9mPLHurtWzEfKqUEa1iC71bXjw5wrvhv9BYW8JSUELHmDquftQyKdq0DZXhULMHGQLf4e95WIaoA14LL\nbThz77kuhKULPTu2MNrBUKGorurhGugo5gs4ZUezSsUOe3KxYdrFMdGgny1GgTxMSMTp2RAZytKjv4kQ\nVx7XgzvpQLIbDjUPAkJv6lScwIRq1W3Ne0Rh0V6Bmn6U5uIuWnJjULmbaQiSODj3z0mAZvak0mSWIGwT\nTX83HztcC4W7e1f6a1thmcc5K61Icehla2hBELWPpixTkyC4eEVmk9Rq0m0ZXtx0JX2ZQXqXDEyePyMe\nJ70sdSzXk72zusqhY4yuOMGgbYNHqxOToK6NxujR7e4dV3Wk5JnSUthym8scjcPeCiKDNY4cHfTMnDXJ\n9zLVy01LtNKYpJ1s8FxVxigmxQNKEbIamxhx6yqwGC4aiISVOOUEjvNOdaUfXfUsE6jEwtwxyGxjlRK1\ncLyxXttq4QWN6PehgHv7jXykzPjInbEysebFvvPOOMdunmJvcCNMSvjUda8fL6xfGo0FDrLg8XZipd6S\noPVdYtyIM1Dg40KbBA3JuumPYtXuJaHrZnjZmdnM5OVo4ZNxktfCVT0c6bnD4bAeyn4bYt1ZPaX6hQHh\nJtvNYfpD0ONYlmqKuToQAMlz52Fh6bj45EbX89L5eLlSpWeyBlGotzriB0EPlclrGi5l2B5oPb1aB1ag\nyyYuu44l0F1oOVYnBIZsxIsHVITxi9lEuVPFkWASOUNuVQXfM4n5hxWR9qtuKnIcPsvbJsv1U10XlKh3\nKisqPhHU15xrCLr5gwFxPUKiNTLUBrkzgBOHXPVsHcLCiSD0YU56TRGfvEom43TWUKPPfl9Z54tgVQuT\njCRlaljAzeniQIcbbHZnn3f0HxbDG3DFYqWSxNrXabHhRsIOhhUHSPENyhGSTVO5t0XX5CdMspJPCd02\n3Oqv32ccbUK4O3YH6LEvp0WO3kSl5n50odVkI9B0i0iq4UPFGMkM8bEQJbgJoOH71P10vtdevJFQE4g2\nyhimiM53ZJRWgSZveHtENZc0Gjo0F9eioak9BnPpY1QxAFPC817svuhEstcU69bLCA4D1rO5R8AuIIBq\nyQJcifFLvbpAEYTLKJqysZrU8EEl3TSdC13A9hZvk4NC8VGEDAxcNrKw313dZp17kZPO5HSd1y6sljAW\nA9M1d6FMYV5SlBWf3WZNCUPS7qKNlda2YBsC6IUVB363f5RLGQOQHwbaijBSRCkrVoRxBHtc0Bd5J9V9\nP5uMTXkpZOxRcCQvImGgcmGuxxLb5zTqfS2xu7v3Sf3IIesSt9tVzcEcdbEvLGVJkLk4mb3G30DbIbri\nPZ09JkweDvMaQ3bxT2nfkz3Ilihkw9jqikkCCCz7E8h6z6KbhQErEW9VzJZzMCgJsyPjFam6iNwpe07S\nhyOvNVw2t9wpzL5xM11DvVzQwDaWEytNRHzDBs4KwEtpI2IpjUyVZHSwA0UGqqkzoCgrJFlNOvPlXqcS\nIcREouUIBmuttkrhPWJtSxOOgpsdvBR3kTOzAXNzSKxoaBAb0c5SDMUc6FIyGA8x5wg5DkUgjFUUodEt\nOYaB2VHVePW9mxHeBTdKWLzJow4ZZvjnoBuVigXljKCNh137ckV2y3Yg3Xi4UzJEI2V5Rw9AfnMs7xUw\nVHOFCg189maD3bmZAe7b4eaGZhyy4HVKjqCXmIH7vsEjRvbnfB0SQxxpuqBDJbHNCtW4vM643ZQQBVPP\na7oXSQIq9w2dHp0A7dtkocCZdQp9FKR9XdJAFIbVSHzIF1ZogeZlc0pXuNE0tagvD57xwDRFkAuoQyMu\nYDdZasXrpSmEE5UjHVkyYsISn8QsfXurzDybX468aoRoks654jjmRY5zi1oB8TcMdC2c3sicNaqfeuhd\nH1nPX7l4RpdqWMR7gGx9slXtG8S3KxpOi4qCD7yg3saD66nun4dzksQURoTUdXyrJR5UpHsfIlTF1aJa\nMdXyQtQnrkl00TeghQd00rRFZsCnhi0qrCSKiBfB2EVrd9RPpbgwJGZHuIQecdBmNetc2ylSEClqVBPR\nGOPPIxrnswEZjmnS0jxKW9VSM1QVxSPJnPFswCqT95SoKD6CP4xdX28WIUGiNaIKodXXJHEIsXBCxLsr\nPwWPCtoplC6hhpKmW5dQo92iCTyY2KioKzO8XR6FKm6qonMKVEwQNtlYE9c97KMtEnp25VOdMP46SQXS\nYsSVp7vm8LP87VYI8SOKcW3s2oedYFtt45rvDzoTF0GmS6wELQ9uo98HhjQAI1Dt91cgjJOwygNmLoZE\nX5K2zQiNA163uMCl5xzaBqY4YTL0wgALg3IFdYSp0RFYLWdt6IxoGI1tnoxcjlUEPo5eGIc3mS3SmaLn\nOdumfUQQ4Jgmgaa5anUVQsfBDrlAN5oaX7O0JO71SSPSWiHBsT9WIPy2J1Cace9ZZLRxblFPSXcvsuHh\nhvnhWQltEDAe7MgvkFQ8lGVFa8jhzijoF9kLmMhMILSzYnfXnZPNP7TlAAwlLHK1RqlpHskJqb6CPpGP\nQvOAhEMsM3zJ2KejZx0esxkjxA0ZufVvGAMN3vTUMplQaF4RiQkp9fzBXf3CMk01dWjOMMIEXTeKzIQe\nEcffzjixWU9FpAyGp2rVl4ETRgqljOGw4UgK31r0ZIEGnH0xGz1FtbW1OcQM008JVujRqulCucEMmntr\n", + "encoding": "custom" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/requestcompression/putcontentwithencoding" + } + ] + }, + "aws.protocoltests.restjson#QueryIdempotencyTokenAutoFill": { + "requests": [ + { + "appliesTo": "client", + "body": "", + "documentation": "Automatically adds idempotency token when not set", + "id": "RestJsonQueryIdempotencyTokenAutoFill", + "method": "POST", + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "token=00000000-0000-4000-8000-000000000000" + ], + "uri": "/QueryIdempotencyTokenAutoFill" + }, + { + "appliesTo": "client", + "body": "", + "documentation": "Uses the given idempotency token as-is", + "id": "RestJsonQueryIdempotencyTokenAutoFillIsSet", + "method": "POST", + "params": { + "token": "00000000-0000-4000-8000-000000000000" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "token=00000000-0000-4000-8000-000000000000" + ], + "uri": "/QueryIdempotencyTokenAutoFill" + } + ] + }, + "aws.protocoltests.restjson#QueryParamsAsStringListMap": { + "requests": [ + { + "appliesTo": "client", + "body": "", + "documentation": "Serialize query params from map of list strings", + "id": "RestJsonQueryParamsStringListMap", + "method": "POST", + "params": { + "foo": { + "baz": [ + "bar", + "qux" + ] + }, + "qux": "named" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "corge=named", + "baz=bar", + "baz=qux" + ], + "uri": "/StringListMap" + } + ] + }, + "aws.protocoltests.restjson#QueryPrecedence": { + "requests": [ + { + "appliesTo": "client", + "body": "", + "documentation": "Prefer named query parameters when serializing", + "id": "RestJsonQueryPrecedence", + "method": "POST", + "params": { + "baz": { + "bar": "fromMap", + "qux": "alsoFromMap" + }, + "foo": "named" + }, + "protocol": "aws.protocols#restJson1", + "queryParams": [ + "bar=named", + "qux=alsoFromMap" + ], + "uri": "/Precedence" + } + ] + }, + "aws.protocoltests.restjson#RecursiveShapes": { + "requests": [ + { + "body": "{\n \"nested\": {\n \"foo\": \"Foo1\",\n \"nested\": {\n \"bar\": \"Bar1\",\n \"recursiveMember\": {\n \"foo\": \"Foo2\",\n \"nested\": {\n \"bar\": \"Bar2\"\n }\n }\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes recursive structures", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonRecursiveShapes", + "method": "PUT", + "params": { + "nested": { + "foo": "Foo1", + "nested": { + "bar": "Bar1", + "recursiveMember": { + "foo": "Foo2", + "nested": { + "bar": "Bar2" + } + } + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/RecursiveShapes" + } + ], + "responses": [ + { + "body": "{\n \"nested\": {\n \"foo\": \"Foo1\",\n \"nested\": {\n \"bar\": \"Bar1\",\n \"recursiveMember\": {\n \"foo\": \"Foo2\",\n \"nested\": {\n \"bar\": \"Bar2\"\n }\n }\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes recursive structures", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonRecursiveShapes", + "params": { + "nested": { + "foo": "Foo1", + "nested": { + "bar": "Bar1", + "recursiveMember": { + "foo": "Foo2", + "nested": { + "bar": "Bar2" + } + } + } + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#SimpleScalarProperties": { + "requests": [ + { + "body": "{\n \"stringValue\": \"string\",\n \"trueBooleanValue\": true,\n \"falseBooleanValue\": false,\n \"byteValue\": 1,\n \"shortValue\": 2,\n \"integerValue\": 3,\n \"longValue\": 4,\n \"floatValue\": 5.5,\n \"DoubleDribble\": 6.5\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes simple scalar properties", + "headers": { + "Content-Type": "application/json", + "X-Foo": "Foo" + }, + "id": "RestJsonSimpleScalarProperties", + "method": "PUT", + "params": { + "byteValue": 1, + "doubleValue": 6.5, + "falseBooleanValue": false, + "floatValue": 5.5, + "foo": "Foo", + "integerValue": 3, + "longValue": 4, + "shortValue": 2, + "stringValue": "string", + "trueBooleanValue": true + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SimpleScalarProperties" + }, + { + "appliesTo": "client", + "body": "{}", + "bodyMediaType": "application/json", + "documentation": "Rest Json should not serialize null structure values", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDoesntSerializeNullStructureValues", + "method": "PUT", + "params": { + "stringValue": null + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SimpleScalarProperties" + }, + { + "body": "{\n \"floatValue\": \"NaN\",\n \"DoubleDribble\": \"NaN\"\n}", + "bodyMediaType": "application/json", + "documentation": "Supports handling NaN float values.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSupportsNaNFloatInputs", + "method": "PUT", + "params": { + "doubleValue": "NaN", + "floatValue": "NaN" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SimpleScalarProperties" + }, + { + "body": "{\n \"floatValue\": \"Infinity\",\n \"DoubleDribble\": \"Infinity\"\n}", + "bodyMediaType": "application/json", + "documentation": "Supports handling Infinity float values.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSupportsInfinityFloatInputs", + "method": "PUT", + "params": { + "doubleValue": "Infinity", + "floatValue": "Infinity" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SimpleScalarProperties" + }, + { + "body": "{\n \"floatValue\": \"-Infinity\",\n \"DoubleDribble\": \"-Infinity\"\n}", + "bodyMediaType": "application/json", + "documentation": "Supports handling -Infinity float values.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSupportsNegativeInfinityFloatInputs", + "method": "PUT", + "params": { + "doubleValue": "-Infinity", + "floatValue": "-Infinity" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SimpleScalarProperties" + } + ], + "responses": [ + { + "body": "{\n \"stringValue\": \"string\",\n \"trueBooleanValue\": true,\n \"falseBooleanValue\": false,\n \"byteValue\": 1,\n \"shortValue\": 2,\n \"integerValue\": 3,\n \"longValue\": 4,\n \"floatValue\": 5.5,\n \"DoubleDribble\": 6.5\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes simple scalar properties", + "headers": { + "Content-Type": "application/json", + "X-Foo": "Foo" + }, + "id": "RestJsonSimpleScalarProperties", + "params": { + "byteValue": 1, + "doubleValue": 6.5, + "falseBooleanValue": false, + "floatValue": 5.5, + "foo": "Foo", + "integerValue": 3, + "longValue": 4, + "shortValue": 2, + "stringValue": "string", + "trueBooleanValue": true + }, + "protocol": "aws.protocols#restJson1" + }, + { + "appliesTo": "client", + "body": "{\n \"stringValue\": null\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Rest Json should not deserialize null structure values", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDoesntDeserializeNullStructureValues", + "params": {}, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"floatValue\": \"NaN\",\n \"DoubleDribble\": \"NaN\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Supports handling NaN float values.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSupportsNaNFloatInputs", + "params": { + "doubleValue": "NaN", + "floatValue": "NaN" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"floatValue\": \"Infinity\",\n \"DoubleDribble\": \"Infinity\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Supports handling Infinity float values.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSupportsInfinityFloatInputs", + "params": { + "doubleValue": "Infinity", + "floatValue": "Infinity" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"floatValue\": \"-Infinity\",\n \"DoubleDribble\": \"-Infinity\"\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Supports handling -Infinity float values.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSupportsNegativeInfinityFloatInputs", + "params": { + "doubleValue": "-Infinity", + "floatValue": "-Infinity" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#SparseJsonLists": { + "requests": [ + { + "body": "{\n \"sparseStringList\": [\n null,\n \"hi\"\n ],\n \"sparseShortList\": [\n null,\n 2\n ]\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes null values in sparse lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSparseListsSerializeNull", + "method": "PUT", + "params": { + "sparseShortList": [ + null, + 2 + ], + "sparseStringList": [ + null, + "hi" + ] + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SparseJsonLists" + } + ], + "responses": [ + { + "body": "{\n \"sparseStringList\": [\n null,\n \"hi\"\n ],\n \"sparseShortList\": [\n null,\n 2\n ]\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Serializes null values in sparse lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSparseListsSerializeNull", + "params": { + "sparseShortList": [ + null, + 2 + ], + "sparseStringList": [ + null, + "hi" + ] + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#SparseJsonMaps": { + "requests": [ + { + "body": "{\n \"sparseStructMap\": {\n \"foo\": {\n \"hi\": \"there\"\n },\n \"baz\": {\n \"hi\": \"bye\"\n }\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes JSON maps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSparseJsonMaps", + "method": "POST", + "params": { + "sparseStructMap": { + "baz": { + "hi": "bye" + }, + "foo": { + "hi": "there" + } + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SparseJsonMaps" + }, + { + "body": "{\n \"sparseBooleanMap\": {\n \"x\": null\n },\n \"sparseNumberMap\": {\n \"x\": null\n },\n \"sparseStringMap\": {\n \"x\": null\n },\n \"sparseStructMap\": {\n \"x\": null\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes JSON map values in sparse maps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializesSparseNullMapValues", + "method": "POST", + "params": { + "sparseBooleanMap": { + "x": null + }, + "sparseNumberMap": { + "x": null + }, + "sparseStringMap": { + "x": null + }, + "sparseStructMap": { + "x": null + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SparseJsonMaps" + }, + { + "body": "{\n \"sparseNumberMap\": {\n \"x\": 0\n },\n \"sparseBooleanMap\": {\n \"x\": false\n }\n}", + "bodyMediaType": "application/json", + "documentation": "Ensure that 0 and false are sent over the wire in all maps and lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializesZeroValuesInSparseMaps", + "method": "POST", + "params": { + "sparseBooleanMap": { + "x": false + }, + "sparseNumberMap": { + "x": 0 + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SparseJsonMaps" + }, + { + "body": "{\n \"sparseSetMap\": {\n \"x\": [],\n \"y\": [\"a\", \"b\"]\n }\n}", + "bodyMediaType": "application/json", + "documentation": "A request that contains a sparse map of sets", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializesSparseSetMap", + "method": "POST", + "params": { + "sparseSetMap": { + "x": [], + "y": [ + "a", + "b" + ] + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SparseJsonMaps" + }, + { + "body": "{\n \"sparseSetMap\": {\n \"x\": [],\n \"y\": [\"a\", \"b\"],\n \"z\": null\n }\n}", + "bodyMediaType": "application/json", + "documentation": "A request that contains a sparse map of sets.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSerializesSparseSetMapAndRetainsNull", + "method": "POST", + "params": { + "sparseSetMap": { + "x": [], + "y": [ + "a", + "b" + ], + "z": null + } + }, + "protocol": "aws.protocols#restJson1", + "uri": "/SparseJsonMaps" + } + ], + "responses": [ + { + "body": "{\n \"sparseStructMap\": {\n \"foo\": {\n \"hi\": \"there\"\n },\n \"baz\": {\n \"hi\": \"bye\"\n }\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes JSON maps", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonSparseJsonMaps", + "params": { + "sparseStructMap": { + "baz": { + "hi": "bye" + }, + "foo": { + "hi": "there" + } + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"sparseBooleanMap\": {\n \"x\": null\n },\n \"sparseNumberMap\": {\n \"x\": null\n },\n \"sparseStringMap\": {\n \"x\": null\n },\n \"sparseStructMap\": {\n \"x\": null\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Deserializes null JSON map values", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializesSparseNullMapValues", + "params": { + "sparseBooleanMap": { + "x": null + }, + "sparseNumberMap": { + "x": null + }, + "sparseStringMap": { + "x": null + }, + "sparseStructMap": { + "x": null + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"sparseNumberMap\": {\n \"x\": 0\n },\n \"sparseBooleanMap\": {\n \"x\": false\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "Ensure that 0 and false are sent over the wire in all maps and lists", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializesZeroValuesInSparseMaps", + "params": { + "sparseBooleanMap": { + "x": false + }, + "sparseNumberMap": { + "x": 0 + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"sparseSetMap\": {\n \"x\": [],\n \"y\": [\"a\", \"b\"]\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "A response that contains a sparse map of sets", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializesSparseSetMap", + "params": { + "sparseSetMap": { + "x": [], + "y": [ + "a", + "b" + ] + } + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "{\n \"sparseSetMap\": {\n \"x\": [],\n \"y\": [\"a\", \"b\"],\n \"z\": null\n }\n}", + "bodyMediaType": "application/json", + "code": 200, + "documentation": "A response that contains a sparse map of sets.", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonDeserializesSparseSetMapAndRetainsNull", + "params": { + "sparseSetMap": { + "x": [], + "y": [ + "a", + "b" + ], + "z": null + } + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#StreamingTraits": { + "requests": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes a blob in the HTTP payload", + "headers": { + "Content-Type": "application/octet-stream", + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsWithBlob", + "method": "POST", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/StreamingTraits" + }, + { + "body": "", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes an empty blob in the HTTP payload", + "headers": { + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsWithNoBlobBody", + "method": "POST", + "params": { + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/StreamingTraits" + } + ], + "responses": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "code": 200, + "documentation": "Serializes a blob in the HTTP payload", + "headers": { + "Content-Type": "application/octet-stream", + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsWithBlob", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1" + }, + { + "body": "", + "bodyMediaType": "application/octet-stream", + "code": 200, + "documentation": "Serializes an empty blob in the HTTP payload", + "headers": { + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsWithNoBlobBody", + "params": { + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#StreamingTraitsRequireLength": { + "requests": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes a blob in the HTTP payload with a required length", + "headers": { + "Content-Type": "application/octet-stream", + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsRequireLengthWithBlob", + "method": "POST", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/StreamingTraitsRequireLength" + }, + { + "body": "", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes an empty blob in the HTTP payload", + "headers": { + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsRequireLengthWithNoBlobBody", + "method": "POST", + "params": { + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/StreamingTraitsRequireLength" + } + ] + }, + "aws.protocoltests.restjson#StreamingTraitsWithMediaType": { + "requests": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes a blob in the HTTP payload with a content-type", + "headers": { + "Content-Type": "text/plain", + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsWithMediaTypeWithBlob", + "method": "POST", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/StreamingTraitsWithMediaType" + } + ], + "responses": [ + { + "body": "blobby blob blob", + "bodyMediaType": "application/octet-stream", + "code": 200, + "documentation": "Serializes a blob in the HTTP payload with a content-type", + "headers": { + "Content-Type": "text/plain", + "X-Foo": "Foo" + }, + "id": "RestJsonStreamingTraitsWithMediaTypeWithBlob", + "params": { + "blob": "blobby blob blob", + "foo": "Foo" + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#TestBodyStructure": { + "requests": [ + { + "body": "{\"testConfig\":\n {\"timeout\": 10}\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a structure", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonTestBodyStructure", + "method": "POST", + "params": { + "testConfig": { + "timeout": 10 + } + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/body" + }, + { + "body": "{}", + "bodyMediaType": "application/json", + "documentation": "Serializes an empty structure in the body", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonHttpWithEmptyBody", + "method": "POST", + "params": {}, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/body" + } + ] + }, + "aws.protocoltests.restjson#TestGetNoInputNoPayload": { + "requests": [ + { + "body": "", + "documentation": "Serializes a GET request for an operation with no input, and therefore no modeled body", + "forbidHeaders": [ + "Content-Type", + "Content-Length" + ], + "id": "RestJsonHttpGetWithNoInput", + "method": "GET", + "params": {}, + "protocol": "aws.protocols#restJson1", + "uri": "/no_input_no_payload" + } + ] + }, + "aws.protocoltests.restjson#TestGetNoPayload": { + "requests": [ + { + "body": "", + "documentation": "Serializes a GET request with no modeled body", + "forbidHeaders": [ + "Content-Length", + "Content-Type" + ], + "id": "RestJsonHttpGetWithNoModeledBody", + "method": "GET", + "params": {}, + "protocol": "aws.protocols#restJson1", + "uri": "/no_payload" + }, + { + "body": "", + "documentation": "Serializes a GET request with header member but no modeled body", + "forbidHeaders": [ + "Content-Length", + "Content-Type" + ], + "headers": { + "X-Amz-Test-Id": "t-12345" + }, + "id": "RestJsonHttpGetWithHeaderMemberNoModeledBody", + "method": "GET", + "params": { + "testId": "t-12345" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/no_payload" + } + ] + }, + "aws.protocoltests.restjson#TestPayloadBlob": { + "requests": [ + { + "body": "", + "bodyMediaType": "application/octet-stream", + "documentation": "Serializes a payload targeting an empty blob", + "headers": {}, + "id": "RestJsonHttpWithEmptyBlobPayload", + "method": "POST", + "params": {}, + "protocol": "aws.protocols#restJson1", + "uri": "/blob_payload" + }, + { + "body": "1234", + "bodyMediaType": "image/jpg", + "documentation": "Serializes a payload targeting a blob", + "headers": { + "Content-Type": "image/jpg" + }, + "id": "RestJsonTestPayloadBlob", + "method": "POST", + "params": { + "contentType": "image/jpg", + "data": "1234" + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/blob_payload" + } + ] + }, + "aws.protocoltests.restjson#TestPayloadStructure": { + "requests": [ + { + "body": "{}", + "bodyMediaType": "application/json", + "documentation": "Serializes a payload targeting an empty structure", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonHttpWithEmptyStructurePayload", + "method": "POST", + "params": {}, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/payload" + }, + { + "body": "{\"data\": 25\n}", + "bodyMediaType": "application/json", + "documentation": "Serializes a payload targeting a structure", + "headers": { + "Content-Type": "application/json" + }, + "id": "RestJsonTestPayloadStructure", + "method": "POST", + "params": { + "payloadConfig": { + "data": 25 + } + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/payload" + }, + { + "body": "{}", + "bodyMediaType": "application/json", + "documentation": "Serializes an request with header members but no payload", + "headers": { + "Content-Type": "application/json", + "X-Amz-Test-Id": "t-12345" + }, + "id": "RestJsonHttpWithHeadersButNoPayload", + "method": "POST", + "params": { + "testId": "t-12345" + }, + "protocol": "aws.protocols#restJson1", + "requireHeaders": [ + "Content-Length" + ], + "uri": "/payload" + } + ] + }, + "aws.protocoltests.restjson#TestPostNoInputNoPayload": { + "requests": [ + { + "body": "", + "documentation": "Serializes a POST request for an operation with no input, and therefore no modeled body", + "forbidHeaders": [ + "Content-Type" + ], + "id": "RestJsonHttpPostWithNoInput", + "method": "POST", + "params": {}, + "protocol": "aws.protocols#restJson1", + "uri": "/no_input_no_payload" + } + ] + }, + "aws.protocoltests.restjson#TestPostNoPayload": { + "requests": [ + { + "body": "", + "documentation": "Serializes a POST request with no modeled body", + "forbidHeaders": [ + "Content-Type" + ], + "id": "RestJsonHttpPostWithNoModeledBody", + "method": "POST", + "params": {}, + "protocol": "aws.protocols#restJson1", + "uri": "/no_payload" + }, + { + "body": "", + "documentation": "Serializes a POST request with header member but no modeled body", + "forbidHeaders": [ + "Content-Type" + ], + "headers": { + "X-Amz-Test-Id": "t-12345" + }, + "id": "RestJsonHttpWithPostHeaderMemberNoModeledBody", + "method": "POST", + "params": { + "testId": "t-12345" + }, + "protocol": "aws.protocols#restJson1", + "uri": "/no_payload" + } + ] + }, + "aws.protocoltests.restjson#TimestampFormatHeaders": { + "requests": [ + { + "body": "", + "documentation": "Tests how timestamp request headers are serialized", + "headers": { + "X-defaultFormat": "Mon, 16 Dec 2019 23:48:18 GMT", + "X-memberDateTime": "2019-12-16T23:48:18Z", + "X-memberEpochSeconds": "1576540098", + "X-memberHttpDate": "Mon, 16 Dec 2019 23:48:18 GMT", + "X-targetDateTime": "2019-12-16T23:48:18Z", + "X-targetEpochSeconds": "1576540098", + "X-targetHttpDate": "Mon, 16 Dec 2019 23:48:18 GMT" + }, + "id": "RestJsonTimestampFormatHeaders", + "method": "POST", + "params": { + "defaultFormat": 1576540098, + "memberDateTime": 1576540098, + "memberEpochSeconds": 1576540098, + "memberHttpDate": 1576540098, + "targetDateTime": 1576540098, + "targetEpochSeconds": 1576540098, + "targetHttpDate": 1576540098 + }, + "protocol": "aws.protocols#restJson1", + "uri": "/TimestampFormatHeaders" + } + ], + "responses": [ + { + "code": 200, + "documentation": "Tests how timestamp response headers are serialized", + "headers": { + "X-defaultFormat": "Mon, 16 Dec 2019 23:48:18 GMT", + "X-memberDateTime": "2019-12-16T23:48:18Z", + "X-memberEpochSeconds": "1576540098", + "X-memberHttpDate": "Mon, 16 Dec 2019 23:48:18 GMT", + "X-targetDateTime": "2019-12-16T23:48:18Z", + "X-targetEpochSeconds": "1576540098", + "X-targetHttpDate": "Mon, 16 Dec 2019 23:48:18 GMT" + }, + "id": "RestJsonTimestampFormatHeaders", + "params": { + "defaultFormat": 1576540098, + "memberDateTime": 1576540098, + "memberEpochSeconds": 1576540098, + "memberHttpDate": 1576540098, + "targetDateTime": 1576540098, + "targetEpochSeconds": 1576540098, + "targetHttpDate": 1576540098 + }, + "protocol": "aws.protocols#restJson1" + } + ] + }, + "aws.protocoltests.restjson#UnitInputAndOutput": { + "requests": [ + { + "body": "", + "documentation": "A unit type input serializes no payload. When clients do not\nneed to serialize any data in the payload, they should omit\na payload altogether.", + "id": "RestJsonUnitInputAndOutput", + "method": "POST", + "protocol": "aws.protocols#restJson1", + "uri": "/UnitInputAndOutput" + } + ], + "responses": [ + { + "body": "", + "code": 200, + "documentation": "When an operation defines Unit output, the service will respond\nwith an empty payload, and may optionally include the content-type\nheader.", + "id": "RestJsonUnitInputAndOutputNoOutput", + "protocol": "aws.protocols#restJson1" + } + ] + } +} diff --git a/scripts/codegen-output-py/pyrightconfig.json b/scripts/codegen-output-py/pyrightconfig.json index 7691bd305..1d6cc0c95 100644 --- a/scripts/codegen-output-py/pyrightconfig.json +++ b/scripts/codegen-output-py/pyrightconfig.json @@ -19,6 +19,7 @@ "../../codegen-output-py/partitioned-types/src", "../../codegen-output-py/query-compatible-aws-json-1-0/src", "../../codegen-output-py/query-compatible-rpcv2-cbor/src", + "../../codegen-output-py/rest-json-1-client/src", "../../codegen-output-py/rest-json-1/src", "../../codegen-output-py/rest-xml-with-namespace/src", "../../codegen-output-py/rest-xml/src", diff --git a/scripts/codegen-output-py/tests/test_client_protocol_vectors.py b/scripts/codegen-output-py/tests/test_client_protocol_vectors.py index 5843ee3ec..451547e0c 100644 --- a/scripts/codegen-output-py/tests/test_client_protocol_vectors.py +++ b/scripts/codegen-output-py/tests/test_client_protocol_vectors.py @@ -24,17 +24,26 @@ from pathlib import Path from types import ModuleType from typing import Any, cast +from urllib.parse import parse_qsl import pytest +from smithy_aws_core.aio.identity.static import AsyncStaticCredentialsResolver +from smithy_aws_core.identity.components import AWSCredentialsIdentity +from smithy_aws_core.identity.static import StaticCredentialsResolver from smithy_cbor import loads as cbor_loads from smithy_core.aio.types import AsyncBytesReader +from smithy_core.documents import Document from smithy_core.retries import SimpleRetryStrategy from smithy_core.schemas import Schema from smithy_core.shapes import ShapeType +from smithy_core.traits import EnumValueTrait, HTTPHeaderTrait from smithy_http import HTTPResponse, tuples_to_fields from smithy_http.interfaces import HTTPRequest, HTTPRequestConfiguration +from smithy_http.utils import split_header +from smithy_python import aws from smithy_python.clients import ClientPlan from smithy_python.generation import ClientSettings +from smithy_python.integrations import ClientNames from smithy_python.model import load_model from smithy_test import deep_equal @@ -44,11 +53,19 @@ (_INPUTS / "client-projections.json").read_text() ) -# Vectors the Java-generated clients also fail. A defaulted member is a plain field -# carrying its default, so the client cannot tell an unset member from one set to -# its default, and it always serializes top-level defaults. +# Vectors the Java-generated clients also fail, by case ID. A defaulted member is a +# plain field carrying its default, so the client cannot tell an unset member from +# one set to its default, and it always serializes top-level defaults. Clients don't +# support the httpChecksumRequired or requestCompression traits yet. _EXPECTED_FAILURES = frozenset( { + "RestJsonClientPopulatesDefaultValuesInInput", + "RestJsonClientSkipsTopLevelDefaultValuesInInput", + "RestJsonClientUsesExplicitlyProvidedMemberValuesOverDefaults", + "RestJsonClientIgnoresNonTopLevelDefaultsOnMembersWithClientOptional", + "RestJsonHttpChecksumRequired", + "SDKAppliedContentEncoding_restJson1", + "SDKAppendedGzipAfterProvidedEncoding_restJson1", "RpcV2CborClientPopulatesDefaultValuesInInput", "RpcV2CborClientSkipsTopLevelDefaultValuesInInput", "RpcV2CborClientUsesExplicitlyProvidedMemberValuesOverDefaults", @@ -60,14 +77,37 @@ } ) -# How each protocol's request bodies are decoded for comparison. JSON numbers are -# read as Decimal, so big numbers compare exactly. +# Response vectors that share a case ID with a passing request vector. The client +# reads an empty blob payload as b"", not as unset. +_EXPECTED_RESPONSE_FAILURES = frozenset({"RestJsonHttpPayloadTraitsWithNoBlobBody"}) + +# How request bodies of each media type are decoded for comparison. Other bodies +# compare as bytes. JSON numbers are read as Decimal, so big numbers compare exactly. _BODY_DECODERS: dict[str, Any] = { - "smithy.protocols#rpcv2Cbor": cbor_loads, - "smithy.protocols#rpcv2Json": lambda body: json.loads(body, parse_float=Decimal), + "application/cbor": cbor_loads, + "application/json": lambda body: json.loads(body, parse_float=Decimal), } +_CREDENTIALS = AWSCredentialsIdentity( + access_key_id="test-access-key-id", secret_access_key="test-secret-access-key" +) + + +def _projection_model(settings: dict[str, Any]) -> dict[str, Any]: + """The projection's model without the operations it omits, as generate.py + generates it.""" + model: dict[str, Any] = json.loads((_INPUTS / settings["model"]).read_text()) + omitted = set(settings.get("omitOperations", ())) + service = model["shapes"][settings["service"]] + service["operations"] = [ + operation + for operation in service.get("operations", ()) + if operation["target"] not in omitted + ] + return model + + def _vector_body(case: dict[str, Any]) -> bytes: """A vector's body as bytes. Binary media types are written in base64.""" body = case.get("body", "") @@ -90,14 +130,17 @@ def _vectors() -> Iterator[Any]: if not path.exists(): continue vectors = json.loads(path.read_text(), parse_float=Decimal) + omitted = set(settings.get("omitOperations", ())) for shape_id, kinds in vectors.items(): + if shape_id in omitted: + continue for kind, cases in sorted(kinds.items()): for case in cases: - marks = ( - [pytest.mark.xfail(strict=True)] - if case["id"] in _EXPECTED_FAILURES - else [] + failing = case["id"] in _EXPECTED_FAILURES or ( + kind == "responses" + and case["id"] in _EXPECTED_RESPONSE_FAILURES ) + marks = [pytest.mark.xfail(strict=True)] if failing else [] yield pytest.param( _Vector(projection, shape_id, kind, case), id=f"{projection}-{case['id']}", @@ -114,8 +157,9 @@ class _Client: """Client method name by operation shape ID.""" error_operations: dict[str, str] """The first operation, in model order, that returns each error.""" - services: tuple[str, str] - """The sync and async client class names.""" + names: ClientNames + aws: bool + """Whether the configs resolve from the environment, with AWS credentials.""" _CLIENTS: dict[str, _Client] = {} @@ -133,7 +177,7 @@ def _client(projection: str) -> _Client: finally: sys.path.pop(0) plan = ClientPlan.from_model( - load_model(json.loads((_INPUTS / settings["model"]).read_text())), + load_model(_projection_model(settings)), ClientSettings(package_name, settings["version"], None), service_id=settings["service"], ) @@ -142,9 +186,25 @@ def _client(projection: str) -> _Client: for operation in plan.operations: for error in operation.operation.errors: error_operations.setdefault(str(error), str(operation.operation.id)) - services = (plan.symbols.service_name, plan.symbols.aio_service_name) + service = plan.selection.service + assert service is not None + names = ClientNames( + client=plan.symbols.service_name, + config="Config", + async_client=plan.symbols.aio_service_name, + async_config="AsyncConfig", + ) + integrations = [i for i in aws.AWS_INTEGRATIONS if i.matches(service)] + for integration in integrations: + names = integration.client_names(service, names) client = _Client( - package, models, models._registry, methods, error_operations, services + package, + models, + models._registry, + methods, + error_operations, + names, + aws=bool(integrations), ) _CLIENTS[projection] = client return client @@ -200,18 +260,37 @@ def _call( response: HTTPResponse | None, *, aio: bool, + host: str = "example.com", ) -> Any: - config = (client.package.AsyncConfig if aio else client.package.Config)( - endpoint_uri="https://example.com", - transport=(_AsyncTransport if aio else _Transport)(response), - retry_strategy=SimpleRetryStrategy(max_attempts=1), - ) - service = client.services[1 if aio else 0] - method = getattr( - getattr(client.package, service)(config), client.methods[operation] - ) - result = method(request) - return asyncio.run(result) if aio else result + names = client.names + config_type = getattr(client.package, names.async_config if aio else names.config) + service = getattr(client.package, names.async_client if aio else names.client) + fields: dict[str, Any] = { + "endpoint_uri": f"https://{host}", + "transport": (_AsyncTransport if aio else _Transport)(response), + "retry_strategy": SimpleRetryStrategy(max_attempts=1), + } + new_config = config_type + if client.aws: + # An AWS config resolves from the environment, so it gets a region and + # credentials. + new_config = config_type.resolve + fields["region"] = "us-east-1" + fields["aws_credentials_identity_resolver"] = ( + AsyncStaticCredentialsResolver if aio else StaticCredentialsResolver + )(_CREDENTIALS) + if not aio: + return getattr(service(new_config(**fields)), client.methods[operation])( + request + ) + + async def run() -> Any: + config = new_config(**fields) + if client.aws: + config = await config + return await getattr(service(config), client.methods[operation])(request) + + return asyncio.run(run()) def _operation_schema(client: _Client, operation: str) -> Any: @@ -233,6 +312,8 @@ def _scalar(schema: Schema, value: Any) -> Any: return float(value) case ShapeType.BIG_DECIMAL: return Decimal(value) + case ShapeType.DOCUMENT: + return Document(value) case _: return value @@ -269,8 +350,44 @@ def _input(registry: Any, schema: Schema, value: Any) -> Any: return _scalar(schema, value) +def _placeholder(registry: Any, schema: Schema) -> Any: + """The smallest input the client accepts, as a response vector's request.""" + match schema.shape_type: + case ShapeType.STRUCTURE: + members, required, _ = schema.get_extension(registry._input_plan) + return { + key: _placeholder(registry, _target(members[key])) for key in required + } + case ShapeType.UNION: + member = schema.members_by_index[0] + key = registry._field_names(schema)[member.expect_member_index()] + return {key: _placeholder(registry, _target(member))} + case ShapeType.LIST: + return [] + case ShapeType.MAP: + return {} + case ShapeType.ENUM | ShapeType.INT_ENUM: + trait = schema.members_by_index[0].get_trait(EnumValueTrait) + assert trait is not None + return trait.value + case ShapeType.BOOLEAN: + return False + case ShapeType.STRING: + return "x" + case ShapeType.BLOB: + return b"" + case ShapeType.TIMESTAMP: + return datetime.fromtimestamp(0, UTC) + case ShapeType.DOCUMENT: + return Document(None) + case _: + return _scalar(schema, 0) + + def _output(registry: Any, schema: Schema, value: Any) -> Any: """A vector's params as the model a client method returns.""" + if value is None: + return None match schema.shape_type: case ShapeType.STRUCTURE: names = registry._field_names(schema) @@ -309,13 +426,20 @@ def _body(request: HTTPRequest) -> bytes: return asyncio.run(data) if asyncio.iscoroutine(data) else data -def _decoded(protocol: str, body: bytes) -> Any: - return _BODY_DECODERS[protocol](body) if body else {} +def _decoded(media_type: str, body: bytes) -> Any: + return _BODY_DECODERS[media_type](body) if body else {} @pytest.mark.parametrize("aio", [False, True], ids=["sync-client", "async-client"]) @pytest.mark.parametrize("vector", list(_vectors())) -def test_protocol_vector(vector: _Vector, aio: bool) -> None: +def test_protocol_vector( + vector: _Vector, aio: bool, monkeypatch: pytest.MonkeyPatch +) -> None: + # Vectors expect this token when the client fills an idempotency token. + monkeypatch.setattr( + "smithy_core._pipeline._default_idempotency_token", + lambda: "00000000-0000-4000-8000-000000000000", + ) client = _client(vector.projection) case = vector.case if vector.kind == "requests": @@ -329,8 +453,10 @@ def _check_request( ) -> None: schema = _operation_schema(client, operation).input_schema request = _input(client.registry, schema, case.get("params", {})) + # A vector's host may have a path, which prefixes the request's path. + host = case.get("host", "example.com") with pytest.raises(Exception) as raised: - _call(client, operation, request, None, aio=aio) + _call(client, operation, request, None, aio=aio, host=host) # The pipeline may wrap the transport's exception. error: BaseException | None = raised.value while error is not None and not isinstance(error, _Sent): @@ -340,19 +466,52 @@ def _check_request( assert actual.method == case["method"] assert actual.destination.path == case["uri"] + assert actual.destination.host == case.get("resolvedHost", host).split("/")[0] + query = actual.destination.query + segments = query.split("&") if query else [] + for segment in case.get("queryParams", ()): + assert segment in segments, (segment, segments) + segments.remove(segment) + keys = [key.lower() for key, _ in parse_qsl(query or "", keep_blank_values=True)] + for key in case.get("forbidQueryParams", ()): + assert key.lower() not in keys + for key in case.get("requireQueryParams", ()): + assert key.lower() in keys + lists = _list_headers(schema) for key, value in case.get("headers", {}).items(): - assert value in actual.fields[key].values + # A vector joins a list header's values, and an empty list sends none. + expected = ( + split_header(value, handle_unquoted_http_date=lists[key.lower()]) + if key.lower() in lists + else [value] + ) + for item in expected: + assert item in actual.fields[key].values, (key, item) for key in case.get("forbidHeaders", ()): with pytest.raises(KeyError): actual.fields[key] for key in case.get("requireHeaders", ()): assert actual.fields[key].values if "body" in case: - expected = _vector_body(case) - protocol = case["protocol"] - assert deep_equal( - _decoded(protocol, _body(actual)), _decoded(protocol, expected) - ) + media_type = case.get("bodyMediaType") + actual_body, expected_body = _body(actual), _vector_body(case) + if media_type in _BODY_DECODERS: + assert deep_equal( + _decoded(media_type, actual_body), _decoded(media_type, expected_body) + ) + else: + assert actual_body == expected_body + + +def _list_headers(schema: Schema) -> dict[str, bool]: + """Whether each list-bound header, by lowercase name, lists timestamps.""" + return { + trait.key.lower(): _target(_target(member).members["member"]).shape_type + is ShapeType.TIMESTAMP + for member in schema.members.values() + if (trait := member.get_trait(HTTPHeaderTrait)) is not None + and _target(member).shape_type is ShapeType.LIST + } def _check_response( @@ -375,8 +534,11 @@ def _check_response( ) expected = _output(client.registry, error_schema, params) error_type = cast("type[Exception]", type(expected)) + request = _placeholder( + client.registry, _operation_schema(client, operation).input_schema + ) with pytest.raises(error_type) as raised: - _call(client, operation, {}, response, aio=aio) + _call(client, operation, request, response, aio=aio) for name in params: field = client.registry._field_names(error_schema)[ error_schema.members[name].expect_member_index() @@ -384,9 +546,10 @@ def _check_response( assert deep_equal(getattr(raised.value, field), getattr(expected, field)) return - output_schema = _operation_schema(client, shape_id).output_schema - expected = _output(client.registry, output_schema, params) - actual = _call(client, shape_id, {}, response, aio=aio) + schema = _operation_schema(client, shape_id) + expected = _output(client.registry, schema.output_schema, params) + request = _placeholder(client.registry, schema.input_schema) + actual = _call(client, shape_id, request, response, aio=aio) assert deep_equal(actual, expected), (actual, expected) @@ -399,5 +562,6 @@ def test_vectors_match_their_provenance() -> None: def test_every_client_vector_is_collected() -> None: # The Java clients run the same vectors: rpcv2Cbor has 29 request and 43 - # response vectors, and rpcv2Json has 34 and 39. - assert len(list(_vectors())) == 72 + 73 + # response vectors, and rpcv2Json has 34 and 39. restJson1 has 244, less the 8 + # of the streaming operations the client omits. + assert len(list(_vectors())) == 72 + 73 + 236 diff --git a/scripts/verifications/import-cost.json b/scripts/verifications/import-cost.json index 97585f4cc..0a29e2987 100644 --- a/scripts/verifications/import-cost.json +++ b/scripts/verifications/import-cost.json @@ -16,7 +16,7 @@ "smithy_json": 21, "smithy_json (all public modules)": 21, "smithy_python": 1, - "smithy_python (all public modules)": 33, + "smithy_python (all public modules)": 34, "smithy_test": 44, "smithy_test (all public modules)": 60, "smithy_xml": 20,