[
    {
        "description": "Test cases for AllQueryStringTypes operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "AllQueryStringTypesInput": {
                "type": "structure",
                "members": {
                    "queryString": {
                        "shape": "String",
                        "location": "querystring",
                        "locationName": "String"
                    },
                    "queryStringList": {
                        "shape": "StringList",
                        "location": "querystring",
                        "locationName": "StringList"
                    },
                    "queryStringSet": {
                        "shape": "StringSet",
                        "location": "querystring",
                        "locationName": "StringSet"
                    },
                    "queryByte": {
                        "shape": "Integer",
                        "location": "querystring",
                        "locationName": "Byte"
                    },
                    "queryShort": {
                        "shape": "Integer",
                        "location": "querystring",
                        "locationName": "Short"
                    },
                    "queryInteger": {
                        "shape": "Integer",
                        "location": "querystring",
                        "locationName": "Integer"
                    },
                    "queryIntegerList": {
                        "shape": "IntegerList",
                        "location": "querystring",
                        "locationName": "IntegerList"
                    },
                    "queryIntegerSet": {
                        "shape": "IntegerSet",
                        "location": "querystring",
                        "locationName": "IntegerSet"
                    },
                    "queryLong": {
                        "shape": "Long",
                        "location": "querystring",
                        "locationName": "Long"
                    },
                    "queryFloat": {
                        "shape": "Float",
                        "location": "querystring",
                        "locationName": "Float"
                    },
                    "queryDouble": {
                        "shape": "Double",
                        "location": "querystring",
                        "locationName": "Double"
                    },
                    "queryDoubleList": {
                        "shape": "DoubleList",
                        "location": "querystring",
                        "locationName": "DoubleList"
                    },
                    "queryBoolean": {
                        "shape": "Boolean",
                        "location": "querystring",
                        "locationName": "Boolean"
                    },
                    "queryBooleanList": {
                        "shape": "BooleanList",
                        "location": "querystring",
                        "locationName": "BooleanList"
                    },
                    "queryTimestamp": {
                        "shape": "Timestamp",
                        "location": "querystring",
                        "locationName": "Timestamp"
                    },
                    "queryTimestampList": {
                        "shape": "TimestampList",
                        "location": "querystring",
                        "locationName": "TimestampList"
                    },
                    "queryEnum": {
                        "shape": "FooEnum",
                        "location": "querystring",
                        "locationName": "Enum"
                    },
                    "queryEnumList": {
                        "shape": "FooEnumList",
                        "location": "querystring",
                        "locationName": "EnumList"
                    },
                    "queryIntegerEnum": {
                        "shape": "IntegerEnum",
                        "location": "querystring",
                        "locationName": "IntegerEnum"
                    },
                    "queryIntegerEnumList": {
                        "shape": "IntegerEnumList",
                        "location": "querystring",
                        "locationName": "IntegerEnumList"
                    },
                    "queryParamsMapOfStringList": {
                        "shape": "StringListMap",
                        "location": "querystring"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "StringList": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "StringSet": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "Integer": {
                "type": "integer",
                "box": true
            },
            "IntegerList": {
                "type": "list",
                "member": {
                    "shape": "Integer"
                }
            },
            "IntegerSet": {
                "type": "list",
                "member": {
                    "shape": "Integer"
                }
            },
            "Long": {
                "type": "long",
                "box": true
            },
            "Float": {
                "type": "float",
                "box": true
            },
            "Double": {
                "type": "double",
                "box": true
            },
            "DoubleList": {
                "type": "list",
                "member": {
                    "shape": "Double"
                }
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "BooleanList": {
                "type": "list",
                "member": {
                    "shape": "Boolean"
                }
            },
            "Timestamp": {
                "type": "timestamp"
            },
            "TimestampList": {
                "type": "list",
                "member": {
                    "shape": "Timestamp"
                }
            },
            "FooEnum": {
                "type": "string",
                "enum": [
                    "Foo",
                    "Baz",
                    "Bar",
                    "1",
                    "0"
                ]
            },
            "FooEnumList": {
                "type": "list",
                "member": {
                    "shape": "FooEnum"
                }
            },
            "IntegerEnum": {
                "type": "integer",
                "box": true
            },
            "IntegerEnumList": {
                "type": "list",
                "member": {
                    "shape": "IntegerEnum"
                }
            },
            "StringListMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "StringList"
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonAllQueryStringTypes",
                "given": {
                    "name": "AllQueryStringTypes",
                    "http": {
                        "method": "GET",
                        "requestUri": "/AllQueryStringTypesInput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "AllQueryStringTypesInput"
                    },
                    "documentation": "<p>This example uses all query string types.</p>"
                },
                "description": "Serializes query string parameters with all supported types",
                "params": {
                    "queryString": "Hello there",
                    "queryStringList": [
                        "a",
                        "b",
                        "c"
                    ],
                    "queryStringSet": [
                        "a",
                        "b",
                        "c"
                    ],
                    "queryByte": 1,
                    "queryShort": 2,
                    "queryInteger": 3,
                    "queryIntegerList": [
                        1,
                        2,
                        3
                    ],
                    "queryIntegerSet": [
                        1,
                        2,
                        3
                    ],
                    "queryLong": 4,
                    "queryFloat": 1.1,
                    "queryDouble": 1.1,
                    "queryDoubleList": [
                        1.1,
                        2.1,
                        3.1
                    ],
                    "queryBoolean": true,
                    "queryBooleanList": [
                        true,
                        false,
                        true
                    ],
                    "queryTimestamp": 1,
                    "queryTimestampList": [
                        1,
                        2,
                        3
                    ],
                    "queryEnum": "Foo",
                    "queryEnumList": [
                        "Foo",
                        "Baz",
                        "Bar"
                    ],
                    "queryIntegerEnum": 1,
                    "queryIntegerEnumList": [
                        1,
                        2,
                        3
                    ],
                    "queryParamsMapOfStringList": {
                        "String": [
                            "Hello there"
                        ],
                        "StringList": [
                            "a",
                            "b",
                            "c"
                        ],
                        "StringSet": [
                            "a",
                            "b",
                            "c"
                        ],
                        "Byte": [
                            "1"
                        ],
                        "Short": [
                            "2"
                        ],
                        "Integer": [
                            "3"
                        ],
                        "IntegerList": [
                            "1",
                            "2",
                            "3"
                        ],
                        "IntegerSet": [
                            "1",
                            "2",
                            "3"
                        ],
                        "Long": [
                            "4"
                        ],
                        "Float": [
                            "1.1"
                        ],
                        "Double": [
                            "1.1"
                        ],
                        "DoubleList": [
                            "1.1",
                            "2.1",
                            "3.1"
                        ],
                        "Boolean": [
                            "true"
                        ],
                        "BooleanList": [
                            "true",
                            "false",
                            "true"
                        ],
                        "Timestamp": [
                            "1970-01-01T00:00:01Z"
                        ],
                        "TimestampList": [
                            "1970-01-01T00:00:01Z",
                            "1970-01-01T00:00:02Z",
                            "1970-01-01T00:00:03Z"
                        ],
                        "Enum": [
                            "Foo"
                        ],
                        "EnumList": [
                            "Foo",
                            "Baz",
                            "Bar"
                        ],
                        "IntegerEnum": [
                            "1"
                        ],
                        "IntegerEnumList": [
                            "1",
                            "2",
                            "3"
                        ]
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/AllQueryStringTypesInput?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",
                    "body": ""
                }
            },
            {
                "id": "RestJsonQueryStringMap",
                "given": {
                    "name": "AllQueryStringTypes",
                    "http": {
                        "method": "GET",
                        "requestUri": "/AllQueryStringTypesInput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "AllQueryStringTypesInput"
                    },
                    "documentation": "<p>This example uses all query string types.</p>"
                },
                "description": "Handles query string maps",
                "params": {
                    "queryParamsMapOfStringList": {
                        "QueryParamsStringKeyA": [
                            "Foo"
                        ],
                        "QueryParamsStringKeyB": [
                            "Bar"
                        ]
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/AllQueryStringTypesInput?QueryParamsStringKeyA=Foo&QueryParamsStringKeyB=Bar",
                    "body": ""
                }
            },
            {
                "id": "RestJsonQueryStringEscaping",
                "given": {
                    "name": "AllQueryStringTypes",
                    "http": {
                        "method": "GET",
                        "requestUri": "/AllQueryStringTypesInput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "AllQueryStringTypesInput"
                    },
                    "documentation": "<p>This example uses all query string types.</p>"
                },
                "description": "Handles escaping all required characters in the query string.",
                "params": {
                    "queryString": " %:/?#[]@!$&'()*+,;=😹",
                    "queryParamsMapOfStringList": {
                        "String": [
                            " %:/?#[]@!$&'()*+,;=😹"
                        ]
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/AllQueryStringTypesInput?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",
                    "body": ""
                }
            },
            {
                "id": "RestJsonSupportsNaNFloatQueryValues",
                "given": {
                    "name": "AllQueryStringTypes",
                    "http": {
                        "method": "GET",
                        "requestUri": "/AllQueryStringTypesInput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "AllQueryStringTypesInput"
                    },
                    "documentation": "<p>This example uses all query string types.</p>"
                },
                "description": "Supports handling NaN float query values.",
                "params": {
                    "queryFloat": "NaN",
                    "queryDouble": "NaN",
                    "queryParamsMapOfStringList": {
                        "Float": [
                            "NaN"
                        ],
                        "Double": [
                            "NaN"
                        ]
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/AllQueryStringTypesInput?Float=NaN&Double=NaN",
                    "body": ""
                }
            },
            {
                "id": "RestJsonSupportsInfinityFloatQueryValues",
                "given": {
                    "name": "AllQueryStringTypes",
                    "http": {
                        "method": "GET",
                        "requestUri": "/AllQueryStringTypesInput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "AllQueryStringTypesInput"
                    },
                    "documentation": "<p>This example uses all query string types.</p>"
                },
                "description": "Supports handling Infinity float query values.",
                "params": {
                    "queryFloat": "Infinity",
                    "queryDouble": "Infinity",
                    "queryParamsMapOfStringList": {
                        "Float": [
                            "Infinity"
                        ],
                        "Double": [
                            "Infinity"
                        ]
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/AllQueryStringTypesInput?Float=Infinity&Double=Infinity",
                    "body": ""
                }
            },
            {
                "id": "RestJsonSupportsNegativeInfinityFloatQueryValues",
                "given": {
                    "name": "AllQueryStringTypes",
                    "http": {
                        "method": "GET",
                        "requestUri": "/AllQueryStringTypesInput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "AllQueryStringTypesInput"
                    },
                    "documentation": "<p>This example uses all query string types.</p>"
                },
                "description": "Supports handling -Infinity float query values.",
                "params": {
                    "queryFloat": "-Infinity",
                    "queryDouble": "-Infinity",
                    "queryParamsMapOfStringList": {
                        "Float": [
                            "-Infinity"
                        ],
                        "Double": [
                            "-Infinity"
                        ]
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/AllQueryStringTypesInput?Float=-Infinity&Double=-Infinity",
                    "body": ""
                }
            },
            {
                "id": "RestJsonZeroAndFalseQueryValues",
                "given": {
                    "name": "AllQueryStringTypes",
                    "http": {
                        "method": "GET",
                        "requestUri": "/AllQueryStringTypesInput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "AllQueryStringTypesInput"
                    },
                    "documentation": "<p>This example uses all query string types.</p>"
                },
                "description": "Query values of 0 and false are serialized",
                "params": {
                    "queryInteger": 0,
                    "queryBoolean": false,
                    "queryParamsMapOfStringList": {
                        "Integer": [
                            "0"
                        ],
                        "Boolean": [
                            "false"
                        ]
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/AllQueryStringTypesInput?Integer=0&Boolean=false",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for ConstantAndVariableQueryString operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "ConstantAndVariableQueryStringInput": {
                "type": "structure",
                "members": {
                    "baz": {
                        "shape": "String",
                        "location": "querystring",
                        "locationName": "baz"
                    },
                    "maybeSet": {
                        "shape": "String",
                        "location": "querystring",
                        "locationName": "maybeSet"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonConstantAndVariableQueryStringMissingOneValue",
                "given": {
                    "name": "ConstantAndVariableQueryString",
                    "http": {
                        "method": "GET",
                        "requestUri": "/ConstantAndVariableQueryString?foo=bar",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "ConstantAndVariableQueryStringInput"
                    },
                    "documentation": "<p>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).</p>"
                },
                "description": "Mixes constant and variable query string parameters",
                "params": {
                    "baz": "bam"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/ConstantAndVariableQueryString?foo=bar&baz=bam",
                    "body": ""
                }
            },
            {
                "id": "RestJsonConstantAndVariableQueryStringAllValues",
                "given": {
                    "name": "ConstantAndVariableQueryString",
                    "http": {
                        "method": "GET",
                        "requestUri": "/ConstantAndVariableQueryString?foo=bar",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "ConstantAndVariableQueryStringInput"
                    },
                    "documentation": "<p>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).</p>"
                },
                "description": "Mixes constant and variable query string parameters",
                "params": {
                    "baz": "bam",
                    "maybeSet": "yes"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/ConstantAndVariableQueryString?foo=bar&baz=bam&maybeSet=yes",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for ConstantQueryString operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "ConstantQueryStringInput": {
                "type": "structure",
                "required": [
                    "hello"
                ],
                "members": {
                    "hello": {
                        "shape": "String",
                        "location": "uri",
                        "locationName": "hello"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonConstantQueryString",
                "given": {
                    "name": "ConstantQueryString",
                    "http": {
                        "method": "GET",
                        "requestUri": "/ConstantQueryString/{hello}?foo=bar&hello",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "ConstantQueryStringInput"
                    },
                    "documentation": "<p>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 &quot;hello&quot; should in no way conflict with the label, <code>{hello}</code>.</p>"
                },
                "description": "Includes constant query string parameters",
                "params": {
                    "hello": "hi"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/ConstantQueryString/hi?foo=bar&hello",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for DocumentType operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "DocumentTypeInputOutput": {
                "type": "structure",
                "members": {
                    "stringValue": {
                        "shape": "String"
                    },
                    "documentValue": {
                        "shape": "Document"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "Document": {
                "type": "structure",
                "members": {},
                "document": true
            }
        },
        "cases": [
            {
                "id": "DocumentTypeInputWithObject",
                "given": {
                    "name": "DocumentType",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentType",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeInputOutput"
                    },
                    "documentation": "<p>This example serializes a document as part of the payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes document types as part of the JSON request payload with no escaping.",
                "params": {
                    "stringValue": "string",
                    "documentValue": {
                        "foo": "bar"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/DocumentType",
                    "body": "{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "DocumentInputWithString",
                "given": {
                    "name": "DocumentType",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentType",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeInputOutput"
                    },
                    "documentation": "<p>This example serializes a document as part of the payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes document types using a string.",
                "params": {
                    "stringValue": "string",
                    "documentValue": "hello"
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/DocumentType",
                    "body": "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "DocumentInputWithNumber",
                "given": {
                    "name": "DocumentType",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentType",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeInputOutput"
                    },
                    "documentation": "<p>This example serializes a document as part of the payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes document types using a number.",
                "params": {
                    "stringValue": "string",
                    "documentValue": 10
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/DocumentType",
                    "body": "{\n    \"stringValue\": \"string\",\n    \"documentValue\": 10\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "DocumentInputWithBoolean",
                "given": {
                    "name": "DocumentType",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentType",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeInputOutput"
                    },
                    "documentation": "<p>This example serializes a document as part of the payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes document types using a boolean.",
                "params": {
                    "stringValue": "string",
                    "documentValue": true
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/DocumentType",
                    "body": "{\n    \"stringValue\": \"string\",\n    \"documentValue\": true\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "DocumentInputWithList",
                "given": {
                    "name": "DocumentType",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentType",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeInputOutput"
                    },
                    "documentation": "<p>This example serializes a document as part of the payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes document types using a list.",
                "params": {
                    "stringValue": "string",
                    "documentValue": [
                        true,
                        "hi",
                        [
                            1,
                            2
                        ],
                        {
                            "foo": {
                                "baz": [
                                    3,
                                    4
                                ]
                            }
                        }
                    ]
                },
                "serialized": {
                    "method": "PUT",
                    "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}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for DocumentTypeAsMapValue operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "DocumentTypeAsMapValueInputOutput": {
                "type": "structure",
                "members": {
                    "docValuedMap": {
                        "shape": "DocumentValuedMap"
                    }
                }
            },
            "DocumentValuedMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "Document"
                }
            },
            "Document": {
                "type": "structure",
                "members": {},
                "document": true
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "DocumentTypeAsMapValueInput",
                "given": {
                    "name": "DocumentTypeAsMapValue",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentTypeAsMapValue",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeAsMapValueInputOutput"
                    },
                    "documentation": "<p>This example serializes documents as the value of maps.</p>",
                    "idempotent": true
                },
                "description": "Serializes a map that uses documents as the value.",
                "params": {
                    "docValuedMap": {
                        "foo": {
                            "f": 1,
                            "o": 2
                        },
                        "bar": [
                            "b",
                            "a",
                            "r"
                        ],
                        "baz": "BAZ"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/DocumentTypeAsMapValue",
                    "body": "{\n    \"docValuedMap\": {\n        \"foo\": { \"f\": 1, \"o\": 2 },\n        \"bar\": [ \"b\", \"a\", \"r\" ],\n        \"baz\": \"BAZ\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for DocumentTypeAsPayload operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "DocumentTypeAsPayloadInputOutput": {
                "type": "structure",
                "members": {
                    "documentValue": {
                        "shape": "Document"
                    }
                },
                "payload": "documentValue"
            },
            "Document": {
                "type": "structure",
                "members": {},
                "document": true
            }
        },
        "cases": [
            {
                "id": "DocumentTypeAsPayloadInput",
                "given": {
                    "name": "DocumentTypeAsPayload",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentTypeAsPayload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeAsPayloadInputOutput"
                    },
                    "documentation": "<p>This example serializes a document as the entire HTTP payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes a document as the target of the httpPayload trait.",
                "params": {
                    "documentValue": {
                        "foo": "bar"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/DocumentTypeAsPayload",
                    "body": "{\n    \"foo\": \"bar\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "DocumentTypeAsPayloadInputString",
                "given": {
                    "name": "DocumentTypeAsPayload",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/DocumentTypeAsPayload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "DocumentTypeAsPayloadInputOutput"
                    },
                    "documentation": "<p>This example serializes a document as the entire HTTP payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes a document as the target of the httpPayload trait using a string.",
                "params": {
                    "documentValue": "hello"
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/DocumentTypeAsPayload",
                    "body": "\"hello\"",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for EmptyInputAndEmptyOutput operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "EmptyInputAndEmptyOutputInput": {
                "type": "structure",
                "members": {}
            }
        },
        "cases": [
            {
                "id": "RestJsonEmptyInputAndEmptyOutput",
                "given": {
                    "name": "EmptyInputAndEmptyOutput",
                    "http": {
                        "method": "POST",
                        "requestUri": "/EmptyInputAndEmptyOutput",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "EmptyInputAndEmptyOutputInput"
                    },
                    "documentation": "<p>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.</p>"
                },
                "description": "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.",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/EmptyInputAndEmptyOutput",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for EndpointOperation operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {},
        "cases": [
            {
                "id": "RestJsonEndpointTrait",
                "given": {
                    "name": "EndpointOperation",
                    "http": {
                        "method": "POST",
                        "requestUri": "/EndpointOperation",
                        "responseCode": 200
                    },
                    "endpoint": {
                        "hostPrefix": "foo."
                    }
                },
                "description": "Operations can prepend to the given host if they define the\nendpoint trait.",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/EndpointOperation",
                    "body": "",
                    "host": "foo.example.com"
                }
            }
        ],
        "clientEndpoint": "https://example.com"
    },
    {
        "description": "Test cases for EndpointWithHostLabelOperation operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HostLabelInput": {
                "type": "structure",
                "required": [
                    "label"
                ],
                "members": {
                    "label": {
                        "shape": "String",
                        "hostLabel": true
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonEndpointTraitWithHostLabel",
                "given": {
                    "name": "EndpointWithHostLabelOperation",
                    "http": {
                        "method": "POST",
                        "requestUri": "/EndpointWithHostLabelOperation",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HostLabelInput"
                    },
                    "endpoint": {
                        "hostPrefix": "foo.{label}."
                    }
                },
                "description": "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.",
                "params": {
                    "label": "bar"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/EndpointWithHostLabelOperation",
                    "body": "{\"label\": \"bar\"}",
                    "host": "foo.bar.example.com"
                }
            }
        ],
        "clientEndpoint": "https://example.com"
    },
    {
        "description": "Test cases for HostWithPathOperation operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {},
        "cases": [
            {
                "id": "RestJsonHostWithPath",
                "given": {
                    "name": "HostWithPathOperation",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HostWithPathOperation",
                        "responseCode": 200
                    }
                },
                "description": "Custom endpoints supplied by users can have paths",
                "params": {},
                "serialized": {
                    "method": "GET",
                    "uri": "/custom/HostWithPathOperation",
                    "body": "",
                    "host": "example.com/custom"
                }
            }
        ],
        "clientEndpoint": "https://example.com/custom"
    },
    {
        "description": "Test cases for HttpChecksumRequired operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpChecksumRequiredInputOutput": {
                "type": "structure",
                "members": {
                    "foo": {
                        "shape": "String"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpChecksumRequired",
                "given": {
                    "name": "HttpChecksumRequired",
                    "http": {
                        "method": "POST",
                        "requestUri": "/HttpChecksumRequired",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpChecksumRequiredInputOutput"
                    },
                    "documentation": "<p>This example tests httpChecksumRequired trait</p>",
                    "httpChecksumRequired": true
                },
                "description": "Adds Content-MD5 header",
                "params": {
                    "foo": "base64 encoded md5 checksum"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/HttpChecksumRequired",
                    "body": "{\n    \"foo\":\"base64 encoded md5 checksum\"\n}\n",
                    "headers": {
                        "Content-MD5": "iB0/3YSo7maijL0IGOgA9g==",
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpEmptyPrefixHeaders operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpEmptyPrefixHeadersInput": {
                "type": "structure",
                "members": {
                    "prefixHeaders": {
                        "shape": "StringMap",
                        "location": "headers",
                        "locationName": ""
                    },
                    "specificHeader": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "hello"
                    }
                }
            },
            "StringMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "String"
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpEmptyPrefixHeadersRequestClient",
                "given": {
                    "name": "HttpEmptyPrefixHeaders",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpEmptyPrefixHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpEmptyPrefixHeadersInput"
                    },
                    "documentation": "<p>Clients that perform this test extract all headers from the response.</p>"
                },
                "description": "Serializes all request headers, using specific when present",
                "params": {
                    "prefixHeaders": {
                        "x-foo": "Foo",
                        "hello": "Hello"
                    },
                    "specificHeader": "There"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/HttpEmptyPrefixHeaders",
                    "body": "",
                    "headers": {
                        "hello": "There",
                        "x-foo": "Foo"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpEnumPayload operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "EnumPayloadInput": {
                "type": "structure",
                "members": {
                    "payload": {
                        "shape": "StringEnum"
                    }
                },
                "payload": "payload"
            },
            "StringEnum": {
                "type": "string",
                "enum": [
                    "enumvalue"
                ]
            }
        },
        "cases": [
            {
                "id": "RestJsonEnumPayloadRequest",
                "given": {
                    "name": "HttpEnumPayload",
                    "http": {
                        "method": "POST",
                        "requestUri": "/EnumPayload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "EnumPayloadInput"
                    }
                },
                "params": {
                    "payload": "enumvalue"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/EnumPayload",
                    "body": "enumvalue",
                    "headers": {
                        "Content-Type": "text/plain"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpPayloadTraits operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpPayloadTraitsInputOutput": {
                "type": "structure",
                "members": {
                    "foo": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "X-Foo"
                    },
                    "blob": {
                        "shape": "Blob"
                    }
                },
                "payload": "blob"
            },
            "String": {
                "type": "string"
            },
            "Blob": {
                "type": "blob"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpPayloadTraitsWithBlob",
                "given": {
                    "name": "HttpPayloadTraits",
                    "http": {
                        "method": "POST",
                        "requestUri": "/HttpPayloadTraits",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPayloadTraitsInputOutput"
                    },
                    "documentation": "<p>This example serializes a blob shape in the payload.</p> <p>In this example, no JSON document is synthesized because the payload is not a structure or a union type.</p>"
                },
                "description": "Serializes a blob in the HTTP payload",
                "params": {
                    "foo": "Foo",
                    "blob": "blobby blob blob"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/HttpPayloadTraits",
                    "body": "blobby blob blob",
                    "headers": {
                        "Content-Type": "application/octet-stream",
                        "X-Foo": "Foo"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            },
            {
                "id": "RestJsonHttpPayloadTraitsWithNoBlobBody",
                "given": {
                    "name": "HttpPayloadTraits",
                    "http": {
                        "method": "POST",
                        "requestUri": "/HttpPayloadTraits",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPayloadTraitsInputOutput"
                    },
                    "documentation": "<p>This example serializes a blob shape in the payload.</p> <p>In this example, no JSON document is synthesized because the payload is not a structure or a union type.</p>"
                },
                "description": "Serializes an empty blob in the HTTP payload",
                "params": {
                    "foo": "Foo"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/HttpPayloadTraits",
                    "body": "",
                    "headers": {
                        "X-Foo": "Foo"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpPayloadWithStructure operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpPayloadWithStructureInputOutput": {
                "type": "structure",
                "members": {
                    "nested": {
                        "shape": "NestedPayload"
                    }
                },
                "payload": "nested"
            },
            "NestedPayload": {
                "type": "structure",
                "members": {
                    "greeting": {
                        "shape": "String"
                    },
                    "name": {
                        "shape": "String"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpPayloadWithStructure",
                "given": {
                    "name": "HttpPayloadWithStructure",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/HttpPayloadWithStructure",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPayloadWithStructureInputOutput"
                    },
                    "documentation": "<p>This example serializes a structure in the payload.</p> <p>Note that serializing a structure changes the wrapper element name to match the targeted structure.</p>",
                    "idempotent": true
                },
                "description": "Serializes a structure in the payload",
                "params": {
                    "nested": {
                        "greeting": "hello",
                        "name": "Phreddy"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/HttpPayloadWithStructure",
                    "body": "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpPayloadWithUnion operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpPayloadWithUnionInputOutput": {
                "type": "structure",
                "members": {
                    "nested": {
                        "shape": "UnionPayload"
                    }
                },
                "payload": "nested"
            },
            "UnionPayload": {
                "type": "structure",
                "members": {
                    "greeting": {
                        "shape": "String"
                    }
                },
                "union": true
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpPayloadWithUnion",
                "given": {
                    "name": "HttpPayloadWithUnion",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/HttpPayloadWithUnion",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPayloadWithUnionInputOutput"
                    },
                    "documentation": "<p>This example serializes a union in the payload.</p>",
                    "idempotent": true
                },
                "description": "Serializes a union in the payload.",
                "params": {
                    "nested": {
                        "greeting": "hello"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/HttpPayloadWithUnion",
                    "body": "{\n    \"greeting\": \"hello\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            },
            {
                "id": "RestJsonHttpPayloadWithUnsetUnion",
                "given": {
                    "name": "HttpPayloadWithUnion",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/HttpPayloadWithUnion",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPayloadWithUnionInputOutput"
                    },
                    "documentation": "<p>This example serializes a union in the payload.</p>",
                    "idempotent": true
                },
                "description": "No payload is sent if the union has no value.",
                "params": {},
                "serialized": {
                    "method": "PUT",
                    "uri": "/HttpPayloadWithUnion",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpPrefixHeaders operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpPrefixHeadersInput": {
                "type": "structure",
                "members": {
                    "foo": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "x-foo"
                    },
                    "fooMap": {
                        "shape": "StringMap",
                        "location": "headers",
                        "locationName": "x-foo-"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "StringMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "String"
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpPrefixHeadersArePresent",
                "given": {
                    "name": "HttpPrefixHeaders",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpPrefixHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPrefixHeadersInput"
                    },
                    "documentation": "<p>This examples adds headers to the input of a request and response by prefix.</p>"
                },
                "description": "Adds headers by prefix",
                "params": {
                    "foo": "Foo",
                    "fooMap": {
                        "abc": "Abc value",
                        "def": "Def value"
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/HttpPrefixHeaders",
                    "body": "",
                    "headers": {
                        "x-foo": "Foo",
                        "x-foo-abc": "Abc value",
                        "x-foo-def": "Def value"
                    }
                }
            },
            {
                "id": "RestJsonHttpPrefixHeadersAreNotPresent",
                "given": {
                    "name": "HttpPrefixHeaders",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpPrefixHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPrefixHeadersInput"
                    },
                    "documentation": "<p>This examples adds headers to the input of a request and response by prefix.</p>"
                },
                "description": "No prefix headers are serialized because the value is not present",
                "params": {
                    "foo": "Foo",
                    "fooMap": {}
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/HttpPrefixHeaders",
                    "body": "",
                    "headers": {
                        "x-foo": "Foo"
                    }
                }
            },
            {
                "id": "RestJsonHttpPrefixEmptyHeaders",
                "given": {
                    "name": "HttpPrefixHeaders",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpPrefixHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpPrefixHeadersInput"
                    },
                    "documentation": "<p>This examples adds headers to the input of a request and response by prefix.</p>"
                },
                "description": "Serialize prefix headers were the value is present but empty",
                "params": {
                    "fooMap": {
                        "abc": ""
                    }
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/HttpPrefixHeaders",
                    "body": "",
                    "headers": {
                        "x-foo-abc": ""
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpRequestWithFloatLabels operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpRequestWithFloatLabelsInput": {
                "type": "structure",
                "required": [
                    "float",
                    "double"
                ],
                "members": {
                    "float": {
                        "shape": "Float",
                        "location": "uri",
                        "locationName": "float"
                    },
                    "double": {
                        "shape": "Double",
                        "location": "uri",
                        "locationName": "double"
                    }
                }
            },
            "Float": {
                "type": "float",
                "box": true
            },
            "Double": {
                "type": "double",
                "box": true
            }
        },
        "cases": [
            {
                "id": "RestJsonSupportsNaNFloatLabels",
                "given": {
                    "name": "HttpRequestWithFloatLabels",
                    "http": {
                        "method": "GET",
                        "requestUri": "/FloatHttpLabels/{float}/{double}",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithFloatLabelsInput"
                    }
                },
                "description": "Supports handling NaN float label values.",
                "params": {
                    "float": "NaN",
                    "double": "NaN"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/FloatHttpLabels/NaN/NaN",
                    "body": ""
                }
            },
            {
                "id": "RestJsonSupportsInfinityFloatLabels",
                "given": {
                    "name": "HttpRequestWithFloatLabels",
                    "http": {
                        "method": "GET",
                        "requestUri": "/FloatHttpLabels/{float}/{double}",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithFloatLabelsInput"
                    }
                },
                "description": "Supports handling Infinity float label values.",
                "params": {
                    "float": "Infinity",
                    "double": "Infinity"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/FloatHttpLabels/Infinity/Infinity",
                    "body": ""
                }
            },
            {
                "id": "RestJsonSupportsNegativeInfinityFloatLabels",
                "given": {
                    "name": "HttpRequestWithFloatLabels",
                    "http": {
                        "method": "GET",
                        "requestUri": "/FloatHttpLabels/{float}/{double}",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithFloatLabelsInput"
                    }
                },
                "description": "Supports handling -Infinity float label values.",
                "params": {
                    "float": "-Infinity",
                    "double": "-Infinity"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/FloatHttpLabels/-Infinity/-Infinity",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpRequestWithGreedyLabelInPath operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpRequestWithGreedyLabelInPathInput": {
                "type": "structure",
                "required": [
                    "foo",
                    "baz"
                ],
                "members": {
                    "foo": {
                        "shape": "String",
                        "location": "uri",
                        "locationName": "foo"
                    },
                    "baz": {
                        "shape": "String",
                        "location": "uri",
                        "locationName": "baz"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpRequestWithGreedyLabelInPath",
                "given": {
                    "name": "HttpRequestWithGreedyLabelInPath",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpRequestWithGreedyLabelInPath/foo/{foo}/baz/{baz+}",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithGreedyLabelInPathInput"
                    }
                },
                "description": "Serializes greedy labels and normal labels",
                "params": {
                    "foo": "hello/escape",
                    "baz": "there/guy"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/HttpRequestWithGreedyLabelInPath/foo/hello%2Fescape/baz/there/guy",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpRequestWithLabels operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpRequestWithLabelsInput": {
                "type": "structure",
                "required": [
                    "string",
                    "short",
                    "integer",
                    "long",
                    "float",
                    "double",
                    "boolean",
                    "timestamp"
                ],
                "members": {
                    "string": {
                        "shape": "String",
                        "location": "uri",
                        "locationName": "string"
                    },
                    "short": {
                        "shape": "Integer",
                        "location": "uri",
                        "locationName": "short"
                    },
                    "integer": {
                        "shape": "Integer",
                        "location": "uri",
                        "locationName": "integer"
                    },
                    "long": {
                        "shape": "Long",
                        "location": "uri",
                        "locationName": "long"
                    },
                    "float": {
                        "shape": "Float",
                        "location": "uri",
                        "locationName": "float"
                    },
                    "double": {
                        "shape": "Double",
                        "location": "uri",
                        "locationName": "double"
                    },
                    "boolean": {
                        "shape": "Boolean",
                        "documentation": "<p>Serialized in the path as true or false.</p>",
                        "location": "uri",
                        "locationName": "boolean"
                    },
                    "timestamp": {
                        "shape": "Timestamp",
                        "documentation": "<p>Note that this member has no format, so it's serialized as an RFC 3399 date-time.</p>",
                        "location": "uri",
                        "locationName": "timestamp"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "Integer": {
                "type": "integer",
                "box": true
            },
            "Long": {
                "type": "long",
                "box": true
            },
            "Float": {
                "type": "float",
                "box": true
            },
            "Double": {
                "type": "double",
                "box": true
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "Timestamp": {
                "type": "timestamp"
            }
        },
        "cases": [
            {
                "id": "RestJsonInputWithHeadersAndAllParams",
                "given": {
                    "name": "HttpRequestWithLabels",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithLabelsInput"
                    },
                    "documentation": "<p>The example tests how requests are serialized when there's no input payload but there are HTTP labels.</p>"
                },
                "description": "Sends a GET request that uses URI label bindings",
                "params": {
                    "string": "string",
                    "short": 1,
                    "integer": 2,
                    "long": 3,
                    "float": 4.1,
                    "double": 5.1,
                    "boolean": true,
                    "timestamp": 1576540098
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/HttpRequestWithLabels/string/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z",
                    "body": ""
                }
            },
            {
                "id": "RestJsonHttpRequestLabelEscaping",
                "given": {
                    "name": "HttpRequestWithLabels",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpRequestWithLabels/{string}/{short}/{integer}/{long}/{float}/{double}/{boolean}/{timestamp}",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithLabelsInput"
                    },
                    "documentation": "<p>The example tests how requests are serialized when there's no input payload but there are HTTP labels.</p>"
                },
                "description": "Sends a GET request that uses URI label bindings",
                "params": {
                    "string": " %:/?#[]@!$&'()*+,;=😹",
                    "short": 1,
                    "integer": 2,
                    "long": 3,
                    "float": 4.1,
                    "double": 5.1,
                    "boolean": true,
                    "timestamp": 1576540098
                },
                "serialized": {
                    "method": "GET",
                    "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",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpRequestWithLabelsAndTimestampFormat operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpRequestWithLabelsAndTimestampFormatInput": {
                "type": "structure",
                "required": [
                    "memberEpochSeconds",
                    "memberHttpDate",
                    "memberDateTime",
                    "defaultFormat",
                    "targetEpochSeconds",
                    "targetHttpDate",
                    "targetDateTime"
                ],
                "members": {
                    "memberEpochSeconds": {
                        "shape": "SyntheticTimestamp_epoch_seconds",
                        "location": "uri",
                        "locationName": "memberEpochSeconds"
                    },
                    "memberHttpDate": {
                        "shape": "SyntheticTimestamp_http_date",
                        "location": "uri",
                        "locationName": "memberHttpDate"
                    },
                    "memberDateTime": {
                        "shape": "SyntheticTimestamp_date_time",
                        "location": "uri",
                        "locationName": "memberDateTime"
                    },
                    "defaultFormat": {
                        "shape": "Timestamp",
                        "location": "uri",
                        "locationName": "defaultFormat"
                    },
                    "targetEpochSeconds": {
                        "shape": "EpochSeconds",
                        "location": "uri",
                        "locationName": "targetEpochSeconds"
                    },
                    "targetHttpDate": {
                        "shape": "HttpDate",
                        "location": "uri",
                        "locationName": "targetHttpDate"
                    },
                    "targetDateTime": {
                        "shape": "DateTime",
                        "location": "uri",
                        "locationName": "targetDateTime"
                    }
                }
            },
            "SyntheticTimestamp_epoch_seconds": {
                "type": "timestamp",
                "timestampFormat": "unixTimestamp"
            },
            "SyntheticTimestamp_http_date": {
                "type": "timestamp",
                "timestampFormat": "rfc822"
            },
            "SyntheticTimestamp_date_time": {
                "type": "timestamp",
                "timestampFormat": "iso8601"
            },
            "Timestamp": {
                "type": "timestamp"
            },
            "EpochSeconds": {
                "type": "timestamp",
                "timestampFormat": "unixTimestamp"
            },
            "HttpDate": {
                "type": "timestamp",
                "timestampFormat": "rfc822"
            },
            "DateTime": {
                "type": "timestamp",
                "timestampFormat": "iso8601"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpRequestWithLabelsAndTimestampFormat",
                "given": {
                    "name": "HttpRequestWithLabelsAndTimestampFormat",
                    "http": {
                        "method": "GET",
                        "requestUri": "/HttpRequestWithLabelsAndTimestampFormat/{memberEpochSeconds}/{memberHttpDate}/{memberDateTime}/{defaultFormat}/{targetEpochSeconds}/{targetHttpDate}/{targetDateTime}",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithLabelsAndTimestampFormatInput"
                    },
                    "documentation": "<p>The example tests how requests serialize different timestamp formats in the URI path.</p>"
                },
                "description": "Serializes different timestamp formats in URI labels",
                "params": {
                    "memberEpochSeconds": 1576540098,
                    "memberHttpDate": 1576540098,
                    "memberDateTime": 1576540098,
                    "defaultFormat": 1576540098,
                    "targetEpochSeconds": 1576540098,
                    "targetHttpDate": 1576540098,
                    "targetDateTime": 1576540098
                },
                "serialized": {
                    "method": "GET",
                    "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",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpRequestWithRegexLiteral operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "HttpRequestWithRegexLiteralInput": {
                "type": "structure",
                "required": [
                    "str"
                ],
                "members": {
                    "str": {
                        "shape": "String",
                        "location": "uri",
                        "locationName": "str"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonToleratesRegexCharsInSegments",
                "given": {
                    "name": "HttpRequestWithRegexLiteral",
                    "http": {
                        "method": "GET",
                        "requestUri": "/ReDosLiteral/{str}/(a+)+",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "HttpRequestWithRegexLiteralInput"
                    }
                },
                "description": "Path matching is not broken by regex expressions in literal segments",
                "params": {
                    "str": "abc"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/ReDosLiteral/abc/(a+)+",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for HttpStringPayload operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "StringPayloadInput": {
                "type": "structure",
                "members": {
                    "payload": {
                        "shape": "String"
                    }
                },
                "payload": "payload"
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonStringPayloadRequest",
                "given": {
                    "name": "HttpStringPayload",
                    "http": {
                        "method": "POST",
                        "requestUri": "/StringPayload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "StringPayloadInput"
                    }
                },
                "params": {
                    "payload": "rawstring"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/StringPayload",
                    "body": "rawstring",
                    "headers": {
                        "Content-Type": "text/plain"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for InputAndOutputWithHeaders operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "InputAndOutputWithHeadersIO": {
                "type": "structure",
                "members": {
                    "headerString": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "X-String"
                    },
                    "headerByte": {
                        "shape": "Integer",
                        "location": "header",
                        "locationName": "X-Byte"
                    },
                    "headerShort": {
                        "shape": "Integer",
                        "location": "header",
                        "locationName": "X-Short"
                    },
                    "headerInteger": {
                        "shape": "Integer",
                        "location": "header",
                        "locationName": "X-Integer"
                    },
                    "headerLong": {
                        "shape": "Long",
                        "location": "header",
                        "locationName": "X-Long"
                    },
                    "headerFloat": {
                        "shape": "Float",
                        "location": "header",
                        "locationName": "X-Float"
                    },
                    "headerDouble": {
                        "shape": "Double",
                        "location": "header",
                        "locationName": "X-Double"
                    },
                    "headerTrueBool": {
                        "shape": "Boolean",
                        "location": "header",
                        "locationName": "X-Boolean1"
                    },
                    "headerFalseBool": {
                        "shape": "Boolean",
                        "location": "header",
                        "locationName": "X-Boolean2"
                    },
                    "headerStringList": {
                        "shape": "StringList",
                        "location": "header",
                        "locationName": "X-StringList"
                    },
                    "headerStringSet": {
                        "shape": "StringSet",
                        "location": "header",
                        "locationName": "X-StringSet"
                    },
                    "headerIntegerList": {
                        "shape": "IntegerList",
                        "location": "header",
                        "locationName": "X-IntegerList"
                    },
                    "headerBooleanList": {
                        "shape": "BooleanList",
                        "location": "header",
                        "locationName": "X-BooleanList"
                    },
                    "headerTimestampList": {
                        "shape": "TimestampList",
                        "location": "header",
                        "locationName": "X-TimestampList"
                    },
                    "headerEnum": {
                        "shape": "FooEnum",
                        "location": "header",
                        "locationName": "X-Enum"
                    },
                    "headerEnumList": {
                        "shape": "FooEnumList",
                        "location": "header",
                        "locationName": "X-EnumList"
                    },
                    "headerIntegerEnum": {
                        "shape": "IntegerEnum",
                        "location": "header",
                        "locationName": "X-IntegerEnum"
                    },
                    "headerIntegerEnumList": {
                        "shape": "IntegerEnumList",
                        "location": "header",
                        "locationName": "X-IntegerEnumList"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "Integer": {
                "type": "integer",
                "box": true
            },
            "Long": {
                "type": "long",
                "box": true
            },
            "Float": {
                "type": "float",
                "box": true
            },
            "Double": {
                "type": "double",
                "box": true
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "StringList": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "StringSet": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "IntegerList": {
                "type": "list",
                "member": {
                    "shape": "Integer"
                }
            },
            "BooleanList": {
                "type": "list",
                "member": {
                    "shape": "Boolean"
                }
            },
            "TimestampList": {
                "type": "list",
                "member": {
                    "shape": "Timestamp"
                }
            },
            "FooEnum": {
                "type": "string",
                "enum": [
                    "Foo",
                    "Baz",
                    "Bar",
                    "1",
                    "0"
                ]
            },
            "FooEnumList": {
                "type": "list",
                "member": {
                    "shape": "FooEnum"
                }
            },
            "IntegerEnum": {
                "type": "integer",
                "box": true
            },
            "IntegerEnumList": {
                "type": "list",
                "member": {
                    "shape": "IntegerEnum"
                }
            },
            "Timestamp": {
                "type": "timestamp"
            }
        },
        "cases": [
            {
                "id": "RestJsonInputAndOutputWithStringHeaders",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Tests requests with string header bindings",
                "params": {
                    "headerString": "Hello",
                    "headerStringList": [
                        "a",
                        "b",
                        "c"
                    ],
                    "headerStringSet": [
                        "a",
                        "b",
                        "c"
                    ]
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-String": "Hello",
                        "X-StringList": "a, b, c",
                        "X-StringSet": "a, b, c"
                    }
                }
            },
            {
                "id": "RestJsonInputAndOutputWithQuotedStringHeaders",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Tests requests with string list header bindings that require quoting",
                "params": {
                    "headerStringList": [
                        "b,c",
                        "\"def\"",
                        "a"
                    ]
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-StringList": "\"b,c\", \"\\\"def\\\"\", a"
                    }
                }
            },
            {
                "id": "RestJsonInputAndOutputWithNumericHeaders",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Tests requests with numeric header bindings",
                "params": {
                    "headerByte": 1,
                    "headerShort": 123,
                    "headerInteger": 123,
                    "headerLong": 123,
                    "headerFloat": 1.1,
                    "headerDouble": 1.1,
                    "headerIntegerList": [
                        1,
                        2,
                        3
                    ]
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "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": "RestJsonInputAndOutputWithBooleanHeaders",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Tests requests with boolean header bindings",
                "params": {
                    "headerTrueBool": true,
                    "headerFalseBool": false,
                    "headerBooleanList": [
                        true,
                        false,
                        true
                    ]
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-Boolean1": "true",
                        "X-Boolean2": "false",
                        "X-BooleanList": "true, false, true"
                    }
                }
            },
            {
                "id": "RestJsonInputAndOutputWithTimestampHeaders",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Tests requests with timestamp header bindings",
                "params": {
                    "headerTimestampList": [
                        1576540098,
                        1576540098
                    ]
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-TimestampList": "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT"
                    }
                }
            },
            {
                "id": "RestJsonInputAndOutputWithEnumHeaders",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Tests requests with enum header bindings",
                "params": {
                    "headerEnum": "Foo",
                    "headerEnumList": [
                        "Foo",
                        "Bar",
                        "Baz"
                    ]
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-Enum": "Foo",
                        "X-EnumList": "Foo, Bar, Baz"
                    }
                }
            },
            {
                "id": "RestJsonInputAndOutputWithIntEnumHeaders",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Tests requests with intEnum header bindings",
                "params": {
                    "headerIntegerEnum": 1,
                    "headerIntegerEnumList": [
                        1,
                        2,
                        3
                    ]
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-IntegerEnum": "1",
                        "X-IntegerEnumList": "1, 2, 3"
                    }
                }
            },
            {
                "id": "RestJsonSupportsNaNFloatHeaderInputs",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Supports handling NaN float header values.",
                "params": {
                    "headerFloat": "NaN",
                    "headerDouble": "NaN"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-Double": "NaN",
                        "X-Float": "NaN"
                    }
                }
            },
            {
                "id": "RestJsonSupportsInfinityFloatHeaderInputs",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Supports handling Infinity float header values.",
                "params": {
                    "headerFloat": "Infinity",
                    "headerDouble": "Infinity"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-Double": "Infinity",
                        "X-Float": "Infinity"
                    }
                }
            },
            {
                "id": "RestJsonSupportsNegativeInfinityFloatHeaderInputs",
                "given": {
                    "name": "InputAndOutputWithHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/InputAndOutputWithHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "InputAndOutputWithHeadersIO"
                    },
                    "documentation": "<p>The example tests how requests and responses are serialized when there is no input or output payload but there are HTTP header bindings.</p>"
                },
                "description": "Supports handling -Infinity float header values.",
                "params": {
                    "headerFloat": "-Infinity",
                    "headerDouble": "-Infinity"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/InputAndOutputWithHeaders",
                    "body": "",
                    "headers": {
                        "X-Double": "-Infinity",
                        "X-Float": "-Infinity"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for JsonBlobs operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "JsonBlobsInputOutput": {
                "type": "structure",
                "members": {
                    "data": {
                        "shape": "Blob"
                    }
                }
            },
            "Blob": {
                "type": "blob"
            }
        },
        "cases": [
            {
                "id": "RestJsonJsonBlobs",
                "given": {
                    "name": "JsonBlobs",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonBlobs",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonBlobsInputOutput"
                    },
                    "documentation": "<p>Blobs are base64 encoded</p>"
                },
                "description": "Blobs are base64 encoded",
                "params": {
                    "data": "value"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonBlobs",
                    "body": "{\n    \"data\": \"dmFsdWU=\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for JsonEnums operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "JsonEnumsInputOutput": {
                "type": "structure",
                "members": {
                    "fooEnum1": {
                        "shape": "FooEnum"
                    },
                    "fooEnum2": {
                        "shape": "FooEnum"
                    },
                    "fooEnum3": {
                        "shape": "FooEnum"
                    },
                    "fooEnumList": {
                        "shape": "FooEnumList"
                    },
                    "fooEnumSet": {
                        "shape": "FooEnumSet"
                    },
                    "fooEnumMap": {
                        "shape": "FooEnumMap"
                    }
                }
            },
            "FooEnum": {
                "type": "string",
                "enum": [
                    "Foo",
                    "Baz",
                    "Bar",
                    "1",
                    "0"
                ]
            },
            "FooEnumList": {
                "type": "list",
                "member": {
                    "shape": "FooEnum"
                }
            },
            "FooEnumSet": {
                "type": "list",
                "member": {
                    "shape": "FooEnum"
                }
            },
            "FooEnumMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "FooEnum"
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonJsonEnums",
                "given": {
                    "name": "JsonEnums",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonEnums",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonEnumsInputOutput"
                    },
                    "documentation": "<p>This example serializes enums as top level properties, in lists, sets, and maps.</p>",
                    "idempotent": true
                },
                "description": "Serializes simple scalar properties",
                "params": {
                    "fooEnum1": "Foo",
                    "fooEnum2": "0",
                    "fooEnum3": "1",
                    "fooEnumList": [
                        "Foo",
                        "0"
                    ],
                    "fooEnumSet": [
                        "Foo",
                        "0"
                    ],
                    "fooEnumMap": {
                        "hi": "Foo",
                        "zero": "0"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonEnums",
                    "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}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for JsonIntEnums operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "JsonIntEnumsInputOutput": {
                "type": "structure",
                "members": {
                    "integerEnum1": {
                        "shape": "IntegerEnum"
                    },
                    "integerEnum2": {
                        "shape": "IntegerEnum"
                    },
                    "integerEnum3": {
                        "shape": "IntegerEnum"
                    },
                    "integerEnumList": {
                        "shape": "IntegerEnumList"
                    },
                    "integerEnumSet": {
                        "shape": "IntegerEnumSet"
                    },
                    "integerEnumMap": {
                        "shape": "IntegerEnumMap"
                    }
                }
            },
            "IntegerEnum": {
                "type": "integer",
                "box": true
            },
            "IntegerEnumList": {
                "type": "list",
                "member": {
                    "shape": "IntegerEnum"
                }
            },
            "IntegerEnumSet": {
                "type": "list",
                "member": {
                    "shape": "IntegerEnum"
                }
            },
            "IntegerEnumMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "IntegerEnum"
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonJsonIntEnums",
                "given": {
                    "name": "JsonIntEnums",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonIntEnums",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonIntEnumsInputOutput"
                    },
                    "documentation": "<p>This example serializes intEnums as top level properties, in lists, sets, and maps.</p>",
                    "idempotent": true
                },
                "description": "Serializes intEnums as integers",
                "params": {
                    "integerEnum1": 1,
                    "integerEnum2": 2,
                    "integerEnum3": 3,
                    "integerEnumList": [
                        1,
                        2,
                        3
                    ],
                    "integerEnumSet": [
                        1,
                        2
                    ],
                    "integerEnumMap": {
                        "abc": 1,
                        "def": 2
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonIntEnums",
                    "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}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for JsonLists operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "JsonListsInputOutput": {
                "type": "structure",
                "members": {
                    "stringList": {
                        "shape": "StringList"
                    },
                    "stringSet": {
                        "shape": "StringSet"
                    },
                    "integerList": {
                        "shape": "IntegerList"
                    },
                    "booleanList": {
                        "shape": "BooleanList"
                    },
                    "timestampList": {
                        "shape": "TimestampList"
                    },
                    "enumList": {
                        "shape": "FooEnumList"
                    },
                    "intEnumList": {
                        "shape": "IntegerEnumList"
                    },
                    "nestedStringList": {
                        "shape": "NestedStringList"
                    },
                    "structureList": {
                        "shape": "StructureList",
                        "locationName": "myStructureList"
                    }
                }
            },
            "StringList": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "StringSet": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "IntegerList": {
                "type": "list",
                "member": {
                    "shape": "Integer"
                }
            },
            "BooleanList": {
                "type": "list",
                "member": {
                    "shape": "Boolean"
                }
            },
            "TimestampList": {
                "type": "list",
                "member": {
                    "shape": "Timestamp"
                }
            },
            "FooEnumList": {
                "type": "list",
                "member": {
                    "shape": "FooEnum"
                }
            },
            "IntegerEnumList": {
                "type": "list",
                "member": {
                    "shape": "IntegerEnum"
                }
            },
            "NestedStringList": {
                "type": "list",
                "member": {
                    "shape": "StringList"
                },
                "documentation": "<p>A list of lists of strings.</p>"
            },
            "StructureList": {
                "type": "list",
                "member": {
                    "shape": "StructureListMember"
                }
            },
            "StructureListMember": {
                "type": "structure",
                "members": {
                    "a": {
                        "shape": "String",
                        "locationName": "value"
                    },
                    "b": {
                        "shape": "String",
                        "locationName": "other"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "IntegerEnum": {
                "type": "integer",
                "box": true
            },
            "FooEnum": {
                "type": "string",
                "enum": [
                    "Foo",
                    "Baz",
                    "Bar",
                    "1",
                    "0"
                ]
            },
            "Timestamp": {
                "type": "timestamp"
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "Integer": {
                "type": "integer",
                "box": true
            }
        },
        "cases": [
            {
                "id": "RestJsonLists",
                "given": {
                    "name": "JsonLists",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonLists",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonListsInputOutput"
                    },
                    "documentation": "<p>This test case serializes JSON lists for the following cases for both input and output:</p> <ol> <li>Normal JSON lists.</li> <li>Normal JSON sets.</li> <li>JSON lists of lists.</li> <li>Lists of structures.</li> </ol>",
                    "idempotent": true
                },
                "description": "Serializes JSON lists",
                "params": {
                    "stringList": [
                        "foo",
                        "bar"
                    ],
                    "stringSet": [
                        "foo",
                        "bar"
                    ],
                    "integerList": [
                        1,
                        2
                    ],
                    "booleanList": [
                        true,
                        false
                    ],
                    "timestampList": [
                        1398796238,
                        1398796238
                    ],
                    "enumList": [
                        "Foo",
                        "0"
                    ],
                    "intEnumList": [
                        1,
                        2
                    ],
                    "nestedStringList": [
                        [
                            "foo",
                            "bar"
                        ],
                        [
                            "baz",
                            "qux"
                        ]
                    ],
                    "structureList": [
                        {
                            "a": "1",
                            "b": "2"
                        },
                        {
                            "a": "3",
                            "b": "4"
                        }
                    ]
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonLists",
                    "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}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonListsEmpty",
                "given": {
                    "name": "JsonLists",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonLists",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonListsInputOutput"
                    },
                    "documentation": "<p>This test case serializes JSON lists for the following cases for both input and output:</p> <ol> <li>Normal JSON lists.</li> <li>Normal JSON sets.</li> <li>JSON lists of lists.</li> <li>Lists of structures.</li> </ol>",
                    "idempotent": true
                },
                "description": "Serializes empty JSON lists",
                "params": {
                    "stringList": []
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonLists",
                    "body": "{\n    \"stringList\": []\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for JsonMaps operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "JsonMapsInputOutput": {
                "type": "structure",
                "members": {
                    "denseStructMap": {
                        "shape": "DenseStructMap"
                    },
                    "denseNumberMap": {
                        "shape": "DenseNumberMap"
                    },
                    "denseBooleanMap": {
                        "shape": "DenseBooleanMap"
                    },
                    "denseStringMap": {
                        "shape": "DenseStringMap"
                    },
                    "denseSetMap": {
                        "shape": "DenseSetMap"
                    }
                }
            },
            "DenseStructMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "GreetingStruct"
                }
            },
            "DenseNumberMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "Integer"
                }
            },
            "DenseBooleanMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "Boolean"
                }
            },
            "DenseStringMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "String"
                }
            },
            "DenseSetMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "StringSet"
                }
            },
            "StringSet": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "String": {
                "type": "string"
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "Integer": {
                "type": "integer",
                "box": true
            },
            "GreetingStruct": {
                "type": "structure",
                "members": {
                    "hi": {
                        "shape": "String"
                    }
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonJsonMaps",
                "given": {
                    "name": "JsonMaps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonMaps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonMapsInputOutput"
                    },
                    "documentation": "<p>The example tests basic map serialization.</p>"
                },
                "description": "Serializes JSON maps",
                "params": {
                    "denseStructMap": {
                        "foo": {
                            "hi": "there"
                        },
                        "baz": {
                            "hi": "bye"
                        }
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonMaps",
                    "body": "{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializesZeroValuesInMaps",
                "given": {
                    "name": "JsonMaps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonMaps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonMapsInputOutput"
                    },
                    "documentation": "<p>The example tests basic map serialization.</p>"
                },
                "description": "Ensure that 0 and false are sent over the wire in all maps and lists",
                "params": {
                    "denseNumberMap": {
                        "x": 0
                    },
                    "denseBooleanMap": {
                        "x": false
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonMaps",
                    "body": "{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializesDenseSetMap",
                "given": {
                    "name": "JsonMaps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonMaps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonMapsInputOutput"
                    },
                    "documentation": "<p>The example tests basic map serialization.</p>"
                },
                "description": "A request that contains a dense map of sets.",
                "params": {
                    "denseSetMap": {
                        "x": [],
                        "y": [
                            "a",
                            "b"
                        ]
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonMaps",
                    "body": "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for JsonTimestamps operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "JsonTimestampsInputOutput": {
                "type": "structure",
                "members": {
                    "normal": {
                        "shape": "Timestamp"
                    },
                    "dateTime": {
                        "shape": "SyntheticTimestamp_date_time"
                    },
                    "dateTimeOnTarget": {
                        "shape": "DateTime"
                    },
                    "epochSeconds": {
                        "shape": "SyntheticTimestamp_epoch_seconds"
                    },
                    "epochSecondsOnTarget": {
                        "shape": "EpochSeconds"
                    },
                    "httpDate": {
                        "shape": "SyntheticTimestamp_http_date"
                    },
                    "httpDateOnTarget": {
                        "shape": "HttpDate"
                    }
                }
            },
            "Timestamp": {
                "type": "timestamp"
            },
            "SyntheticTimestamp_date_time": {
                "type": "timestamp",
                "timestampFormat": "iso8601"
            },
            "DateTime": {
                "type": "timestamp",
                "timestampFormat": "iso8601"
            },
            "SyntheticTimestamp_epoch_seconds": {
                "type": "timestamp",
                "timestampFormat": "unixTimestamp"
            },
            "EpochSeconds": {
                "type": "timestamp",
                "timestampFormat": "unixTimestamp"
            },
            "SyntheticTimestamp_http_date": {
                "type": "timestamp",
                "timestampFormat": "rfc822"
            },
            "HttpDate": {
                "type": "timestamp",
                "timestampFormat": "rfc822"
            }
        },
        "cases": [
            {
                "id": "RestJsonJsonTimestamps",
                "given": {
                    "name": "JsonTimestamps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonTimestamps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonTimestampsInputOutput"
                    },
                    "documentation": "<p>This tests how timestamps are serialized, including using the default format of date-time and various @timestampFormat trait values.</p>"
                },
                "description": "Tests how normal timestamps are serialized",
                "params": {
                    "normal": 1398796238
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonTimestamps",
                    "body": "{\n    \"normal\": 1398796238\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonJsonTimestampsWithDateTimeFormat",
                "given": {
                    "name": "JsonTimestamps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonTimestamps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonTimestampsInputOutput"
                    },
                    "documentation": "<p>This tests how timestamps are serialized, including using the default format of date-time and various @timestampFormat trait values.</p>"
                },
                "description": "Ensures that the timestampFormat of date-time works like normal timestamps",
                "params": {
                    "dateTime": 1398796238
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonTimestamps",
                    "body": "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonJsonTimestampsWithDateTimeOnTargetFormat",
                "given": {
                    "name": "JsonTimestamps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonTimestamps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonTimestampsInputOutput"
                    },
                    "documentation": "<p>This tests how timestamps are serialized, including using the default format of date-time and various @timestampFormat trait values.</p>"
                },
                "description": "Ensures that the timestampFormat of date-time on the target shape works like normal timestamps",
                "params": {
                    "dateTimeOnTarget": 1398796238
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonTimestamps",
                    "body": "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonJsonTimestampsWithEpochSecondsFormat",
                "given": {
                    "name": "JsonTimestamps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonTimestamps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonTimestampsInputOutput"
                    },
                    "documentation": "<p>This tests how timestamps are serialized, including using the default format of date-time and various @timestampFormat trait values.</p>"
                },
                "description": "Ensures that the timestampFormat of epoch-seconds works",
                "params": {
                    "epochSeconds": 1398796238
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonTimestamps",
                    "body": "{\n    \"epochSeconds\": 1398796238\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat",
                "given": {
                    "name": "JsonTimestamps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonTimestamps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonTimestampsInputOutput"
                    },
                    "documentation": "<p>This tests how timestamps are serialized, including using the default format of date-time and various @timestampFormat trait values.</p>"
                },
                "description": "Ensures that the timestampFormat of epoch-seconds on the target shape works",
                "params": {
                    "epochSecondsOnTarget": 1398796238
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonTimestamps",
                    "body": "{\n    \"epochSecondsOnTarget\": 1398796238\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonJsonTimestampsWithHttpDateFormat",
                "given": {
                    "name": "JsonTimestamps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonTimestamps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonTimestampsInputOutput"
                    },
                    "documentation": "<p>This tests how timestamps are serialized, including using the default format of date-time and various @timestampFormat trait values.</p>"
                },
                "description": "Ensures that the timestampFormat of http-date works",
                "params": {
                    "httpDate": 1398796238
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonTimestamps",
                    "body": "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonJsonTimestampsWithHttpDateOnTargetFormat",
                "given": {
                    "name": "JsonTimestamps",
                    "http": {
                        "method": "POST",
                        "requestUri": "/JsonTimestamps",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "JsonTimestampsInputOutput"
                    },
                    "documentation": "<p>This tests how timestamps are serialized, including using the default format of date-time and various @timestampFormat trait values.</p>"
                },
                "description": "Ensures that the timestampFormat of http-date on the target shape works",
                "params": {
                    "httpDateOnTarget": 1398796238
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/JsonTimestamps",
                    "body": "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for JsonUnions operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "UnionInputOutput": {
                "type": "structure",
                "members": {
                    "contents": {
                        "shape": "MyUnion"
                    }
                },
                "documentation": "<p>A shared structure that contains a single union member.</p>"
            },
            "MyUnion": {
                "type": "structure",
                "members": {
                    "stringValue": {
                        "shape": "String"
                    },
                    "booleanValue": {
                        "shape": "Boolean"
                    },
                    "numberValue": {
                        "shape": "Integer"
                    },
                    "blobValue": {
                        "shape": "Blob"
                    },
                    "timestampValue": {
                        "shape": "Timestamp"
                    },
                    "enumValue": {
                        "shape": "FooEnum"
                    },
                    "listValue": {
                        "shape": "StringList"
                    },
                    "mapValue": {
                        "shape": "StringMap"
                    },
                    "structureValue": {
                        "shape": "GreetingStruct"
                    },
                    "renamedStructureValue": {
                        "shape": "RenamedGreeting"
                    }
                },
                "documentation": "<p>A union with a representative set of types for members.</p>",
                "union": true
            },
            "String": {
                "type": "string"
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "Integer": {
                "type": "integer",
                "box": true
            },
            "Blob": {
                "type": "blob"
            },
            "Timestamp": {
                "type": "timestamp"
            },
            "FooEnum": {
                "type": "string",
                "enum": [
                    "Foo",
                    "Baz",
                    "Bar",
                    "1",
                    "0"
                ]
            },
            "StringList": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "StringMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "String"
                }
            },
            "GreetingStruct": {
                "type": "structure",
                "members": {
                    "hi": {
                        "shape": "String"
                    }
                }
            },
            "RenamedGreeting": {
                "type": "structure",
                "members": {
                    "salutation": {
                        "shape": "String"
                    }
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonSerializeStringUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a string union value",
                "params": {
                    "contents": {
                        "stringValue": "foo"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeBooleanUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a boolean union value",
                "params": {
                    "contents": {
                        "booleanValue": true
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeNumberUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a number union value",
                "params": {
                    "contents": {
                        "numberValue": 1
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeBlobUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a blob union value",
                "params": {
                    "contents": {
                        "blobValue": "foo"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeTimestampUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a timestamp union value",
                "params": {
                    "contents": {
                        "timestampValue": 1398796238
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeEnumUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes an enum union value",
                "params": {
                    "contents": {
                        "enumValue": "Foo"
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeListUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a list union value",
                "params": {
                    "contents": {
                        "listValue": [
                            "foo",
                            "bar"
                        ]
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeMapUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a map union value",
                "params": {
                    "contents": {
                        "mapValue": {
                            "foo": "bar",
                            "spam": "eggs"
                        }
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeStructureUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a structure union value",
                "params": {
                    "contents": {
                        "structureValue": {
                            "hi": "hello"
                        }
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSerializeRenamedStructureUnionValue",
                "given": {
                    "name": "JsonUnions",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/JsonUnions",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "UnionInputOutput"
                    },
                    "documentation": "<p>This operation uses unions for inputs and outputs.</p>",
                    "idempotent": true
                },
                "description": "Serializes a renamed structure union value",
                "params": {
                    "contents": {
                        "renamedStructureValue": {
                            "salutation": "hello!"
                        }
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/JsonUnions",
                    "body": "{\n    \"contents\": {\n        \"renamedStructureValue\": {\n            \"salutation\": \"hello!\"\n        }\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for MediaTypeHeader operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "MediaTypeHeaderInput": {
                "type": "structure",
                "members": {
                    "json": {
                        "shape": "JsonValue",
                        "jsonvalue": true,
                        "location": "header",
                        "locationName": "X-Json"
                    }
                }
            },
            "JsonValue": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "MediaTypeHeaderInputBase64",
                "given": {
                    "name": "MediaTypeHeader",
                    "http": {
                        "method": "GET",
                        "requestUri": "/MediaTypeHeader",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "MediaTypeHeaderInput"
                    },
                    "documentation": "<p>This example ensures that mediaType strings are base64 encoded in headers.</p>"
                },
                "description": "Headers that target strings with a mediaType are base64 encoded",
                "params": {
                    "json": "true"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/MediaTypeHeader",
                    "body": "",
                    "headers": {
                        "X-Json": "dHJ1ZQ=="
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for NoInputAndNoOutput operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {},
        "cases": [
            {
                "id": "RestJsonNoInputAndNoOutput",
                "given": {
                    "name": "NoInputAndNoOutput",
                    "http": {
                        "method": "POST",
                        "requestUri": "/NoInputAndNoOutput",
                        "responseCode": 200
                    },
                    "documentation": "<p>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.</p>"
                },
                "description": "No input serializes no payload. When clients do not need to\nserialize any data in the payload, they should omit a payload\naltogether.",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/NoInputAndNoOutput",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for NoInputAndOutput operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {},
        "cases": [
            {
                "id": "RestJsonNoInputAndOutput",
                "given": {
                    "name": "NoInputAndOutput",
                    "http": {
                        "method": "POST",
                        "requestUri": "/NoInputAndOutputOutput",
                        "responseCode": 200
                    },
                    "documentation": "<p>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.</p>"
                },
                "description": "No input serializes no payload. When clients do not need to\nserialize any data in the payload, they should omit a payload\naltogether.",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/NoInputAndOutputOutput",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for NullAndEmptyHeadersClient operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "NullAndEmptyHeadersIO": {
                "type": "structure",
                "members": {
                    "a": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "X-A"
                    },
                    "b": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "X-B"
                    },
                    "c": {
                        "shape": "StringList",
                        "location": "header",
                        "locationName": "X-C"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "StringList": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonNullAndEmptyHeaders",
                "given": {
                    "name": "NullAndEmptyHeadersClient",
                    "http": {
                        "method": "GET",
                        "requestUri": "/NullAndEmptyHeadersClient",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "NullAndEmptyHeadersIO"
                    },
                    "documentation": "<p>Null headers are not sent over the wire, empty headers are serialized to &quot;&quot;</p>"
                },
                "description": "Do not send null values, but do send empty strings and empty lists over the wire in headers",
                "params": {
                    "a": null,
                    "b": "",
                    "c": []
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/NullAndEmptyHeadersClient",
                    "body": "",
                    "headers": {
                        "X-B": "",
                        "X-C": ""
                    },
                    "forbidHeaders": [
                        "X-A"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for OmitsNullSerializesEmptyString operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "OmitsNullSerializesEmptyStringInput": {
                "type": "structure",
                "members": {
                    "nullValue": {
                        "shape": "String",
                        "location": "querystring",
                        "locationName": "Null"
                    },
                    "emptyString": {
                        "shape": "String",
                        "location": "querystring",
                        "locationName": "Empty"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonOmitsNullQuery",
                "given": {
                    "name": "OmitsNullSerializesEmptyString",
                    "http": {
                        "method": "GET",
                        "requestUri": "/OmitsNullSerializesEmptyString",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "OmitsNullSerializesEmptyStringInput"
                    },
                    "documentation": "<p>Omits null, but serializes empty string value.</p>"
                },
                "description": "Omits null query values",
                "params": {
                    "nullValue": null
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/OmitsNullSerializesEmptyString",
                    "body": ""
                }
            },
            {
                "id": "RestJsonSerializesEmptyQueryValue",
                "given": {
                    "name": "OmitsNullSerializesEmptyString",
                    "http": {
                        "method": "GET",
                        "requestUri": "/OmitsNullSerializesEmptyString",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "OmitsNullSerializesEmptyStringInput"
                    },
                    "documentation": "<p>Omits null, but serializes empty string value.</p>"
                },
                "description": "Serializes empty query strings",
                "params": {
                    "emptyString": ""
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/OmitsNullSerializesEmptyString?Empty=",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for OmitsSerializingEmptyLists operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "OmitsSerializingEmptyListsInput": {
                "type": "structure",
                "members": {
                    "queryStringList": {
                        "shape": "StringList",
                        "location": "querystring",
                        "locationName": "StringList"
                    },
                    "queryIntegerList": {
                        "shape": "IntegerList",
                        "location": "querystring",
                        "locationName": "IntegerList"
                    },
                    "queryDoubleList": {
                        "shape": "DoubleList",
                        "location": "querystring",
                        "locationName": "DoubleList"
                    },
                    "queryBooleanList": {
                        "shape": "BooleanList",
                        "location": "querystring",
                        "locationName": "BooleanList"
                    },
                    "queryTimestampList": {
                        "shape": "TimestampList",
                        "location": "querystring",
                        "locationName": "TimestampList"
                    },
                    "queryEnumList": {
                        "shape": "FooEnumList",
                        "location": "querystring",
                        "locationName": "EnumList"
                    },
                    "queryIntegerEnumList": {
                        "shape": "IntegerEnumList",
                        "location": "querystring",
                        "locationName": "IntegerEnumList"
                    }
                }
            },
            "StringList": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            },
            "IntegerList": {
                "type": "list",
                "member": {
                    "shape": "Integer"
                }
            },
            "DoubleList": {
                "type": "list",
                "member": {
                    "shape": "Double"
                }
            },
            "BooleanList": {
                "type": "list",
                "member": {
                    "shape": "Boolean"
                }
            },
            "TimestampList": {
                "type": "list",
                "member": {
                    "shape": "Timestamp"
                }
            },
            "FooEnumList": {
                "type": "list",
                "member": {
                    "shape": "FooEnum"
                }
            },
            "IntegerEnumList": {
                "type": "list",
                "member": {
                    "shape": "IntegerEnum"
                }
            },
            "IntegerEnum": {
                "type": "integer",
                "box": true
            },
            "FooEnum": {
                "type": "string",
                "enum": [
                    "Foo",
                    "Baz",
                    "Bar",
                    "1",
                    "0"
                ]
            },
            "Timestamp": {
                "type": "timestamp"
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "Double": {
                "type": "double",
                "box": true
            },
            "Integer": {
                "type": "integer",
                "box": true
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonOmitsEmptyListQueryValues",
                "given": {
                    "name": "OmitsSerializingEmptyLists",
                    "http": {
                        "method": "POST",
                        "requestUri": "/OmitsSerializingEmptyLists",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "OmitsSerializingEmptyListsInput"
                    },
                    "documentation": "<p>Omits serializing empty lists. Because empty strings are serilized as <code>Foo=</code>, empty lists cannot also be serialized as <code>Foo=</code> and instead must be omitted.</p>"
                },
                "description": "Supports omitting empty lists.",
                "params": {
                    "queryStringList": [],
                    "queryIntegerList": [],
                    "queryDoubleList": [],
                    "queryBooleanList": [],
                    "queryTimestampList": [],
                    "queryEnumList": [],
                    "queryIntegerEnumList": []
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/OmitsSerializingEmptyLists",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for PostUnionWithJsonName operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "PostUnionWithJsonNameInput": {
                "type": "structure",
                "members": {
                    "value": {
                        "shape": "UnionWithJsonName"
                    }
                }
            },
            "UnionWithJsonName": {
                "type": "structure",
                "members": {
                    "foo": {
                        "shape": "String",
                        "locationName": "FOO"
                    },
                    "bar": {
                        "shape": "String"
                    },
                    "baz": {
                        "shape": "String",
                        "locationName": "_baz"
                    }
                },
                "union": true
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "PostUnionWithJsonNameRequest1",
                "given": {
                    "name": "PostUnionWithJsonName",
                    "http": {
                        "method": "POST",
                        "requestUri": "/PostUnionWithJsonName",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "PostUnionWithJsonNameInput"
                    },
                    "documentation": "<p>This operation defines a union that uses jsonName on some members.</p>"
                },
                "description": "Tests that jsonName works with union members.",
                "params": {
                    "value": {
                        "foo": "hi"
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/PostUnionWithJsonName",
                    "body": "{\n    \"value\": {\n        \"FOO\": \"hi\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "PostUnionWithJsonNameRequest2",
                "given": {
                    "name": "PostUnionWithJsonName",
                    "http": {
                        "method": "POST",
                        "requestUri": "/PostUnionWithJsonName",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "PostUnionWithJsonNameInput"
                    },
                    "documentation": "<p>This operation defines a union that uses jsonName on some members.</p>"
                },
                "description": "Tests that jsonName works with union members.",
                "params": {
                    "value": {
                        "baz": "hi"
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/PostUnionWithJsonName",
                    "body": "{\n    \"value\": {\n        \"_baz\": \"hi\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "PostUnionWithJsonNameRequest3",
                "given": {
                    "name": "PostUnionWithJsonName",
                    "http": {
                        "method": "POST",
                        "requestUri": "/PostUnionWithJsonName",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "PostUnionWithJsonNameInput"
                    },
                    "documentation": "<p>This operation defines a union that uses jsonName on some members.</p>"
                },
                "description": "Tests that jsonName works with union members.",
                "params": {
                    "value": {
                        "bar": "hi"
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/PostUnionWithJsonName",
                    "body": "{\n    \"value\": {\n        \"bar\": \"hi\"\n    }\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for PutWithContentEncoding operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "PutWithContentEncodingInput": {
                "type": "structure",
                "members": {
                    "encoding": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "Content-Encoding"
                    },
                    "data": {
                        "shape": "String"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "SDKAppliedContentEncoding_restJson1",
                "given": {
                    "name": "PutWithContentEncoding",
                    "http": {
                        "method": "POST",
                        "requestUri": "/requestcompression/putcontentwithencoding",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "PutWithContentEncodingInput"
                    },
                    "requestcompression": {
                        "encodings": [
                            "gzip"
                        ]
                    }
                },
                "description": "Compression algorithm encoding is appended to the Content-Encoding header.",
                "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"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/requestcompression/putcontentwithencoding",
                    "headers": {
                        "Content-Encoding": "gzip"
                    }
                }
            },
            {
                "id": "SDKAppendedGzipAfterProvidedEncoding_restJson1",
                "given": {
                    "name": "PutWithContentEncoding",
                    "http": {
                        "method": "POST",
                        "requestUri": "/requestcompression/putcontentwithencoding",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "PutWithContentEncodingInput"
                    },
                    "requestcompression": {
                        "encodings": [
                            "gzip"
                        ]
                    }
                },
                "description": "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",
                "params": {
                    "encoding": "custom",
                    "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"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/requestcompression/putcontentwithencoding",
                    "headers": {
                        "Content-Encoding": "custom, gzip"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for QueryIdempotencyTokenAutoFill operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "QueryIdempotencyTokenAutoFillInput": {
                "type": "structure",
                "members": {
                    "token": {
                        "shape": "String",
                        "idempotencyToken": true,
                        "location": "querystring",
                        "locationName": "token"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonQueryIdempotencyTokenAutoFill",
                "given": {
                    "name": "QueryIdempotencyTokenAutoFill",
                    "http": {
                        "method": "POST",
                        "requestUri": "/QueryIdempotencyTokenAutoFill",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "QueryIdempotencyTokenAutoFillInput"
                    },
                    "documentation": "<p>Automatically adds idempotency tokens.</p>"
                },
                "description": "Automatically adds idempotency token when not set",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/QueryIdempotencyTokenAutoFill?token=00000000-0000-4000-8000-000000000000",
                    "body": ""
                }
            },
            {
                "id": "RestJsonQueryIdempotencyTokenAutoFillIsSet",
                "given": {
                    "name": "QueryIdempotencyTokenAutoFill",
                    "http": {
                        "method": "POST",
                        "requestUri": "/QueryIdempotencyTokenAutoFill",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "QueryIdempotencyTokenAutoFillInput"
                    },
                    "documentation": "<p>Automatically adds idempotency tokens.</p>"
                },
                "description": "Uses the given idempotency token as-is",
                "params": {
                    "token": "00000000-0000-4000-8000-000000000000"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/QueryIdempotencyTokenAutoFill?token=00000000-0000-4000-8000-000000000000",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for QueryParamsAsStringListMap operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "QueryParamsAsStringListMapInput": {
                "type": "structure",
                "members": {
                    "qux": {
                        "shape": "String",
                        "location": "querystring",
                        "locationName": "corge"
                    },
                    "foo": {
                        "shape": "StringListMap",
                        "location": "querystring"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "StringListMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "StringList"
                }
            },
            "StringList": {
                "type": "list",
                "member": {
                    "shape": "String"
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonQueryParamsStringListMap",
                "given": {
                    "name": "QueryParamsAsStringListMap",
                    "http": {
                        "method": "POST",
                        "requestUri": "/StringListMap",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "QueryParamsAsStringListMapInput"
                    }
                },
                "description": "Serialize query params from map of list strings",
                "params": {
                    "qux": "named",
                    "foo": {
                        "baz": [
                            "bar",
                            "qux"
                        ]
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/StringListMap?corge=named&baz=bar&baz=qux",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for QueryPrecedence operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "QueryPrecedenceInput": {
                "type": "structure",
                "members": {
                    "foo": {
                        "shape": "String",
                        "location": "querystring",
                        "locationName": "bar"
                    },
                    "baz": {
                        "shape": "StringMap",
                        "location": "querystring"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "StringMap": {
                "type": "map",
                "key": {
                    "shape": "String"
                },
                "value": {
                    "shape": "String"
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonQueryPrecedence",
                "given": {
                    "name": "QueryPrecedence",
                    "http": {
                        "method": "POST",
                        "requestUri": "/Precedence",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "QueryPrecedenceInput"
                    }
                },
                "description": "Prefer named query parameters when serializing",
                "params": {
                    "foo": "named",
                    "baz": {
                        "bar": "fromMap",
                        "qux": "alsoFromMap"
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/Precedence?bar=named&qux=alsoFromMap",
                    "body": ""
                }
            }
        ]
    },
    {
        "description": "Test cases for RecursiveShapes operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "RecursiveShapesInputOutput": {
                "type": "structure",
                "members": {
                    "nested": {
                        "shape": "RecursiveShapesInputOutputNested1"
                    }
                }
            },
            "RecursiveShapesInputOutputNested1": {
                "type": "structure",
                "members": {
                    "foo": {
                        "shape": "String"
                    },
                    "nested": {
                        "shape": "RecursiveShapesInputOutputNested2"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "RecursiveShapesInputOutputNested2": {
                "type": "structure",
                "members": {
                    "bar": {
                        "shape": "String"
                    },
                    "recursiveMember": {
                        "shape": "RecursiveShapesInputOutputNested1"
                    }
                }
            }
        },
        "cases": [
            {
                "id": "RestJsonRecursiveShapes",
                "given": {
                    "name": "RecursiveShapes",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/RecursiveShapes",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "RecursiveShapesInputOutput"
                    },
                    "documentation": "<p>Recursive shapes</p>",
                    "idempotent": true
                },
                "description": "Serializes recursive structures",
                "params": {
                    "nested": {
                        "foo": "Foo1",
                        "nested": {
                            "bar": "Bar1",
                            "recursiveMember": {
                                "foo": "Foo2",
                                "nested": {
                                    "bar": "Bar2"
                                }
                            }
                        }
                    }
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/RecursiveShapes",
                    "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}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for SimpleScalarProperties operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "SimpleScalarPropertiesInputOutput": {
                "type": "structure",
                "members": {
                    "foo": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "X-Foo"
                    },
                    "stringValue": {
                        "shape": "String"
                    },
                    "trueBooleanValue": {
                        "shape": "Boolean"
                    },
                    "falseBooleanValue": {
                        "shape": "Boolean"
                    },
                    "byteValue": {
                        "shape": "Integer"
                    },
                    "shortValue": {
                        "shape": "Integer"
                    },
                    "integerValue": {
                        "shape": "Integer"
                    },
                    "longValue": {
                        "shape": "Long"
                    },
                    "floatValue": {
                        "shape": "Float"
                    },
                    "doubleValue": {
                        "shape": "Double",
                        "locationName": "DoubleDribble"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "Boolean": {
                "type": "boolean",
                "box": true
            },
            "Integer": {
                "type": "integer",
                "box": true
            },
            "Long": {
                "type": "long",
                "box": true
            },
            "Float": {
                "type": "float",
                "box": true
            },
            "Double": {
                "type": "double",
                "box": true
            }
        },
        "cases": [
            {
                "id": "RestJsonSimpleScalarProperties",
                "given": {
                    "name": "SimpleScalarProperties",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/SimpleScalarProperties",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "SimpleScalarPropertiesInputOutput"
                    },
                    "idempotent": true
                },
                "description": "Serializes simple scalar properties",
                "params": {
                    "foo": "Foo",
                    "stringValue": "string",
                    "trueBooleanValue": true,
                    "falseBooleanValue": false,
                    "byteValue": 1,
                    "shortValue": 2,
                    "integerValue": 3,
                    "longValue": 4,
                    "floatValue": 5.5,
                    "doubleValue": 6.5
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/SimpleScalarProperties",
                    "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}",
                    "headers": {
                        "Content-Type": "application/json",
                        "X-Foo": "Foo"
                    }
                }
            },
            {
                "id": "RestJsonDoesntSerializeNullStructureValues",
                "given": {
                    "name": "SimpleScalarProperties",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/SimpleScalarProperties",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "SimpleScalarPropertiesInputOutput"
                    },
                    "idempotent": true
                },
                "description": "Rest Json should not serialize null structure values",
                "params": {
                    "stringValue": null
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/SimpleScalarProperties",
                    "body": "{}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSupportsNaNFloatInputs",
                "given": {
                    "name": "SimpleScalarProperties",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/SimpleScalarProperties",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "SimpleScalarPropertiesInputOutput"
                    },
                    "idempotent": true
                },
                "description": "Supports handling NaN float values.",
                "params": {
                    "floatValue": "NaN",
                    "doubleValue": "NaN"
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/SimpleScalarProperties",
                    "body": "{\n    \"floatValue\": \"NaN\",\n    \"DoubleDribble\": \"NaN\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSupportsInfinityFloatInputs",
                "given": {
                    "name": "SimpleScalarProperties",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/SimpleScalarProperties",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "SimpleScalarPropertiesInputOutput"
                    },
                    "idempotent": true
                },
                "description": "Supports handling Infinity float values.",
                "params": {
                    "floatValue": "Infinity",
                    "doubleValue": "Infinity"
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/SimpleScalarProperties",
                    "body": "{\n    \"floatValue\": \"Infinity\",\n    \"DoubleDribble\": \"Infinity\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            },
            {
                "id": "RestJsonSupportsNegativeInfinityFloatInputs",
                "given": {
                    "name": "SimpleScalarProperties",
                    "http": {
                        "method": "PUT",
                        "requestUri": "/SimpleScalarProperties",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "SimpleScalarPropertiesInputOutput"
                    },
                    "idempotent": true
                },
                "description": "Supports handling -Infinity float values.",
                "params": {
                    "floatValue": "-Infinity",
                    "doubleValue": "-Infinity"
                },
                "serialized": {
                    "method": "PUT",
                    "uri": "/SimpleScalarProperties",
                    "body": "{\n    \"floatValue\": \"-Infinity\",\n    \"DoubleDribble\": \"-Infinity\"\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for TestBodyStructure operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "TestBodyStructureInputOutput": {
                "type": "structure",
                "members": {
                    "testId": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "x-amz-test-id"
                    },
                    "testConfig": {
                        "shape": "TestConfig"
                    }
                }
            },
            "String": {
                "type": "string"
            },
            "TestConfig": {
                "type": "structure",
                "members": {
                    "timeout": {
                        "shape": "Integer"
                    }
                }
            },
            "Integer": {
                "type": "integer",
                "box": true
            }
        },
        "cases": [
            {
                "id": "RestJsonTestBodyStructure",
                "given": {
                    "name": "TestBodyStructure",
                    "http": {
                        "method": "POST",
                        "requestUri": "/body",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestBodyStructureInputOutput"
                    },
                    "documentation": "<p>This example operation serializes a structure in the HTTP body.</p> <p>It should ensure Content-Type: application/json is used in all requests and that an &quot;empty&quot; body is an empty JSON document ({}).</p>",
                    "idempotent": true
                },
                "description": "Serializes a structure",
                "params": {
                    "testConfig": {
                        "timeout": 10
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/body",
                    "body": "{\"testConfig\":\n    {\"timeout\": 10}\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            },
            {
                "id": "RestJsonHttpWithEmptyBody",
                "given": {
                    "name": "TestBodyStructure",
                    "http": {
                        "method": "POST",
                        "requestUri": "/body",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestBodyStructureInputOutput"
                    },
                    "documentation": "<p>This example operation serializes a structure in the HTTP body.</p> <p>It should ensure Content-Type: application/json is used in all requests and that an &quot;empty&quot; body is an empty JSON document ({}).</p>",
                    "idempotent": true
                },
                "description": "Serializes an empty structure in the body",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/body",
                    "body": "{}",
                    "headers": {
                        "Content-Type": "application/json"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for TestGetNoInputNoPayload operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {},
        "cases": [
            {
                "id": "RestJsonHttpGetWithNoInput",
                "given": {
                    "name": "TestGetNoInputNoPayload",
                    "http": {
                        "method": "GET",
                        "requestUri": "/no_input_no_payload",
                        "responseCode": 200
                    },
                    "documentation": "<p>This example GET operation has no input and serializes a request without a HTTP body.</p> <p>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.</p>"
                },
                "description": "Serializes a GET request for an operation with no input, and therefore no modeled body",
                "params": {},
                "serialized": {
                    "method": "GET",
                    "uri": "/no_input_no_payload",
                    "body": "",
                    "forbidHeaders": [
                        "Content-Type",
                        "Content-Length"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for TestGetNoPayload operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "TestNoPayloadInputOutput": {
                "type": "structure",
                "members": {
                    "testId": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "X-Amz-Test-Id"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpGetWithNoModeledBody",
                "given": {
                    "name": "TestGetNoPayload",
                    "http": {
                        "method": "GET",
                        "requestUri": "/no_payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestNoPayloadInputOutput"
                    },
                    "documentation": "<p>This example GET operation serializes a request without a modeled HTTP body.</p> <p>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.</p>"
                },
                "description": "Serializes a GET request with no modeled body",
                "params": {},
                "serialized": {
                    "method": "GET",
                    "uri": "/no_payload",
                    "body": "",
                    "forbidHeaders": [
                        "Content-Length",
                        "Content-Type"
                    ]
                }
            },
            {
                "id": "RestJsonHttpGetWithHeaderMemberNoModeledBody",
                "given": {
                    "name": "TestGetNoPayload",
                    "http": {
                        "method": "GET",
                        "requestUri": "/no_payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestNoPayloadInputOutput"
                    },
                    "documentation": "<p>This example GET operation serializes a request without a modeled HTTP body.</p> <p>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.</p>"
                },
                "description": "Serializes a GET request with header member but no modeled body",
                "params": {
                    "testId": "t-12345"
                },
                "serialized": {
                    "method": "GET",
                    "uri": "/no_payload",
                    "body": "",
                    "headers": {
                        "X-Amz-Test-Id": "t-12345"
                    },
                    "forbidHeaders": [
                        "Content-Length",
                        "Content-Type"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for TestPayloadBlob operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "TestPayloadBlobInputOutput": {
                "type": "structure",
                "members": {
                    "contentType": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "Content-Type"
                    },
                    "data": {
                        "shape": "Blob"
                    }
                },
                "payload": "data"
            },
            "String": {
                "type": "string"
            },
            "Blob": {
                "type": "blob"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpWithEmptyBlobPayload",
                "given": {
                    "name": "TestPayloadBlob",
                    "http": {
                        "method": "POST",
                        "requestUri": "/blob_payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestPayloadBlobInputOutput"
                    },
                    "documentation": "<p>This example operation serializes a payload targeting a blob.</p> <p>The Blob shape is not structured content and we cannot make assumptions about what data will be sent. This test ensures only a generic &quot;Content-Type: application/octet-stream&quot; header is used, and that we are not treating an empty body as an empty JSON document.</p>",
                    "idempotent": true
                },
                "description": "Serializes a payload targeting an empty blob",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/blob_payload",
                    "body": ""
                }
            },
            {
                "id": "RestJsonTestPayloadBlob",
                "given": {
                    "name": "TestPayloadBlob",
                    "http": {
                        "method": "POST",
                        "requestUri": "/blob_payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestPayloadBlobInputOutput"
                    },
                    "documentation": "<p>This example operation serializes a payload targeting a blob.</p> <p>The Blob shape is not structured content and we cannot make assumptions about what data will be sent. This test ensures only a generic &quot;Content-Type: application/octet-stream&quot; header is used, and that we are not treating an empty body as an empty JSON document.</p>",
                    "idempotent": true
                },
                "description": "Serializes a payload targeting a blob",
                "params": {
                    "contentType": "image/jpg",
                    "data": "1234"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/blob_payload",
                    "body": "1234",
                    "headers": {
                        "Content-Type": "image/jpg"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for TestPayloadStructure operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "TestPayloadStructureInputOutput": {
                "type": "structure",
                "members": {
                    "testId": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "x-amz-test-id"
                    },
                    "payloadConfig": {
                        "shape": "PayloadConfig"
                    }
                },
                "payload": "payloadConfig"
            },
            "String": {
                "type": "string"
            },
            "PayloadConfig": {
                "type": "structure",
                "members": {
                    "data": {
                        "shape": "Integer"
                    }
                }
            },
            "Integer": {
                "type": "integer",
                "box": true
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpWithEmptyStructurePayload",
                "given": {
                    "name": "TestPayloadStructure",
                    "http": {
                        "method": "POST",
                        "requestUri": "/payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestPayloadStructureInputOutput"
                    },
                    "documentation": "<p>This example operation serializes a payload targeting a structure.</p> <p>This enforces the same requirements as TestBodyStructure but with the body specified by the @httpPayload trait.</p>",
                    "idempotent": true
                },
                "description": "Serializes a payload targeting an empty structure",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/payload",
                    "body": "{}",
                    "headers": {
                        "Content-Type": "application/json"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            },
            {
                "id": "RestJsonTestPayloadStructure",
                "given": {
                    "name": "TestPayloadStructure",
                    "http": {
                        "method": "POST",
                        "requestUri": "/payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestPayloadStructureInputOutput"
                    },
                    "documentation": "<p>This example operation serializes a payload targeting a structure.</p> <p>This enforces the same requirements as TestBodyStructure but with the body specified by the @httpPayload trait.</p>",
                    "idempotent": true
                },
                "description": "Serializes a payload targeting a structure",
                "params": {
                    "payloadConfig": {
                        "data": 25
                    }
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/payload",
                    "body": "{\"data\": 25\n}",
                    "headers": {
                        "Content-Type": "application/json"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            },
            {
                "id": "RestJsonHttpWithHeadersButNoPayload",
                "given": {
                    "name": "TestPayloadStructure",
                    "http": {
                        "method": "POST",
                        "requestUri": "/payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestPayloadStructureInputOutput"
                    },
                    "documentation": "<p>This example operation serializes a payload targeting a structure.</p> <p>This enforces the same requirements as TestBodyStructure but with the body specified by the @httpPayload trait.</p>",
                    "idempotent": true
                },
                "description": "Serializes an request with header members but no payload",
                "params": {
                    "testId": "t-12345"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/payload",
                    "body": "{}",
                    "headers": {
                        "Content-Type": "application/json",
                        "X-Amz-Test-Id": "t-12345"
                    },
                    "requireHeaders": [
                        "Content-Length"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for TestPostNoInputNoPayload operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {},
        "cases": [
            {
                "id": "RestJsonHttpPostWithNoInput",
                "given": {
                    "name": "TestPostNoInputNoPayload",
                    "http": {
                        "method": "POST",
                        "requestUri": "/no_input_no_payload",
                        "responseCode": 200
                    },
                    "documentation": "<p>This example POST operation has no input and serializes a request without a HTTP body.</p> <p>These tests are to ensure we do not attach a body or related headers (Content-Type) to a POST operation with no modeled input.</p>"
                },
                "description": "Serializes a POST request for an operation with no input, and therefore no modeled body",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/no_input_no_payload",
                    "body": "",
                    "forbidHeaders": [
                        "Content-Type"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for TestPostNoPayload operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "TestNoPayloadInputOutput": {
                "type": "structure",
                "members": {
                    "testId": {
                        "shape": "String",
                        "location": "header",
                        "locationName": "X-Amz-Test-Id"
                    }
                }
            },
            "String": {
                "type": "string"
            }
        },
        "cases": [
            {
                "id": "RestJsonHttpPostWithNoModeledBody",
                "given": {
                    "name": "TestPostNoPayload",
                    "http": {
                        "method": "POST",
                        "requestUri": "/no_payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestNoPayloadInputOutput"
                    },
                    "documentation": "<p>This example POST operation serializes a request without a modeled HTTP body.</p> <p>These tests are to ensure we do not attach a body or related headers (Content-Type) to a POST operation with no modeled payload.</p>"
                },
                "description": "Serializes a POST request with no modeled body",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/no_payload",
                    "body": "",
                    "forbidHeaders": [
                        "Content-Type"
                    ]
                }
            },
            {
                "id": "RestJsonHttpWithPostHeaderMemberNoModeledBody",
                "given": {
                    "name": "TestPostNoPayload",
                    "http": {
                        "method": "POST",
                        "requestUri": "/no_payload",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TestNoPayloadInputOutput"
                    },
                    "documentation": "<p>This example POST operation serializes a request without a modeled HTTP body.</p> <p>These tests are to ensure we do not attach a body or related headers (Content-Type) to a POST operation with no modeled payload.</p>"
                },
                "description": "Serializes a POST request with header member but no modeled body",
                "params": {
                    "testId": "t-12345"
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/no_payload",
                    "body": "",
                    "headers": {
                        "X-Amz-Test-Id": "t-12345"
                    },
                    "forbidHeaders": [
                        "Content-Type"
                    ]
                }
            }
        ]
    },
    {
        "description": "Test cases for TimestampFormatHeaders operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {
            "TimestampFormatHeadersIO": {
                "type": "structure",
                "members": {
                    "memberEpochSeconds": {
                        "shape": "SyntheticTimestamp_epoch_seconds",
                        "location": "header",
                        "locationName": "X-memberEpochSeconds"
                    },
                    "memberHttpDate": {
                        "shape": "SyntheticTimestamp_http_date",
                        "location": "header",
                        "locationName": "X-memberHttpDate"
                    },
                    "memberDateTime": {
                        "shape": "SyntheticTimestamp_date_time",
                        "location": "header",
                        "locationName": "X-memberDateTime"
                    },
                    "defaultFormat": {
                        "shape": "Timestamp",
                        "location": "header",
                        "locationName": "X-defaultFormat"
                    },
                    "targetEpochSeconds": {
                        "shape": "EpochSeconds",
                        "location": "header",
                        "locationName": "X-targetEpochSeconds"
                    },
                    "targetHttpDate": {
                        "shape": "HttpDate",
                        "location": "header",
                        "locationName": "X-targetHttpDate"
                    },
                    "targetDateTime": {
                        "shape": "DateTime",
                        "location": "header",
                        "locationName": "X-targetDateTime"
                    }
                }
            },
            "SyntheticTimestamp_epoch_seconds": {
                "type": "timestamp",
                "timestampFormat": "unixTimestamp"
            },
            "SyntheticTimestamp_http_date": {
                "type": "timestamp",
                "timestampFormat": "rfc822"
            },
            "SyntheticTimestamp_date_time": {
                "type": "timestamp",
                "timestampFormat": "iso8601"
            },
            "Timestamp": {
                "type": "timestamp"
            },
            "EpochSeconds": {
                "type": "timestamp",
                "timestampFormat": "unixTimestamp"
            },
            "HttpDate": {
                "type": "timestamp",
                "timestampFormat": "rfc822"
            },
            "DateTime": {
                "type": "timestamp",
                "timestampFormat": "iso8601"
            }
        },
        "cases": [
            {
                "id": "RestJsonTimestampFormatHeaders",
                "given": {
                    "name": "TimestampFormatHeaders",
                    "http": {
                        "method": "POST",
                        "requestUri": "/TimestampFormatHeaders",
                        "responseCode": 200
                    },
                    "input": {
                        "shape": "TimestampFormatHeadersIO"
                    },
                    "documentation": "<p>This example tests how timestamp request and response headers are serialized.</p>"
                },
                "description": "Tests how timestamp request headers are serialized",
                "params": {
                    "memberEpochSeconds": 1576540098,
                    "memberHttpDate": 1576540098,
                    "memberDateTime": 1576540098,
                    "defaultFormat": 1576540098,
                    "targetEpochSeconds": 1576540098,
                    "targetHttpDate": 1576540098,
                    "targetDateTime": 1576540098
                },
                "serialized": {
                    "method": "POST",
                    "uri": "/TimestampFormatHeaders",
                    "body": "",
                    "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"
                    }
                }
            }
        ]
    },
    {
        "description": "Test cases for UnitInputAndOutput operation",
        "metadata": {
            "apiVersion": "2019-12-16",
            "auth": [
                "aws.auth#sigv4"
            ],
            "endpointPrefix": "restjson",
            "protocol": "rest-json",
            "protocols": [
                "rest-json"
            ],
            "serviceFullName": "RestJson",
            "serviceId": "Rest Json Protocol",
            "signatureVersion": "v4",
            "signingName": "RestJson",
            "uid": "rest-json-protocol-2019-12-16"
        },
        "shapes": {},
        "cases": [
            {
                "id": "RestJsonUnitInputAndOutput",
                "given": {
                    "name": "UnitInputAndOutput",
                    "http": {
                        "method": "POST",
                        "requestUri": "/UnitInputAndOutput",
                        "responseCode": 200
                    },
                    "documentation": "<p>This test is similar to NoInputAndNoOutput, but uses explicit Unit types.</p>"
                },
                "description": "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.",
                "params": {},
                "serialized": {
                    "method": "POST",
                    "uri": "/UnitInputAndOutput",
                    "body": ""
                }
            }
        ]
    }
]
