diff --git a/.golangci.yml b/.golangci.yml index 8eb595e55..875a3a20b 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -128,7 +128,7 @@ issues: # Not supposed to be constant. - linters: [ goconst ] - text: 'string `(string|number|int32|int64)`' + text: 'string `(string|number|u?int\d{0,2})`' - linters: [ goconst ] text: 'string `(Unix|unix|date|time)' diff --git a/_testdata/positive/format_gen.json b/_testdata/positive/format_gen.json index 608d285c8..c4d14f990 100644 --- a/_testdata/positive/format_gen.json +++ b/_testdata/positive/format_gen.json @@ -90,6 +90,69 @@ } } }, + { + "name": "integer_uint", + "in": "query", + "required": true, + "schema": { + "type": "integer", + "format": "uint" + } + }, + { + "name": "integer_uint32", + "in": "query", + "required": true, + "schema": { + "type": "integer", + "format": "uint32" + } + }, + { + "name": "integer_uint32_array", + "in": "query", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + } + }, + { + "name": "integer_uint64", + "in": "query", + "required": true, + "schema": { + "type": "integer", + "format": "uint64" + } + }, + { + "name": "integer_uint64_array", + "in": "query", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + } + }, + { + "name": "integer_uint_array", + "in": "query", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + }, { "name": "integer_unix", "in": "query", @@ -848,6 +911,27 @@ "format": "int64" } }, + "required_array_integer_uint": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + }, + "required_array_integer_uint32": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + }, + "required_array_integer_uint64": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + }, "required_array_integer_unix": { "type": "array", "items": { @@ -1124,6 +1208,36 @@ } } }, + "required_double_array_integer_uint": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + }, + "required_double_array_integer_uint32": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + } + }, + "required_double_array_integer_uint64": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + } + }, "required_double_array_integer_unix": { "type": "array", "items": { @@ -1462,6 +1576,18 @@ "type": "integer", "format": "int64" }, + "required_integer_uint": { + "type": "integer", + "format": "uint" + }, + "required_integer_uint32": { + "type": "integer", + "format": "uint32" + }, + "required_integer_uint64": { + "type": "integer", + "format": "uint64" + }, "required_integer_unix": { "type": "integer", "format": "unix" @@ -1622,6 +1748,27 @@ "format": "int64" } }, + "optional_array_integer_uint": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + }, + "optional_array_integer_uint32": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + }, + "optional_array_integer_uint64": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + }, "optional_array_integer_unix": { "type": "array", "items": { @@ -1898,6 +2045,36 @@ } } }, + "optional_double_array_integer_uint": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + }, + "optional_double_array_integer_uint32": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + } + }, + "optional_double_array_integer_uint64": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + } + }, "optional_double_array_integer_unix": { "type": "array", "items": { @@ -2236,6 +2413,18 @@ "type": "integer", "format": "int64" }, + "optional_integer_uint": { + "type": "integer", + "format": "uint" + }, + "optional_integer_uint32": { + "type": "integer", + "format": "uint32" + }, + "optional_integer_uint64": { + "type": "integer", + "format": "uint64" + }, "optional_integer_unix": { "type": "integer", "format": "unix" @@ -2373,6 +2562,9 @@ "required_array_integer", "required_array_integer_int32", "required_array_integer_int64", + "required_array_integer_uint", + "required_array_integer_uint32", + "required_array_integer_uint64", "required_array_integer_unix", "required_array_integer_unix-micro", "required_array_integer_unix-milli", @@ -2412,6 +2604,9 @@ "required_double_array_integer", "required_double_array_integer_int32", "required_double_array_integer_int64", + "required_double_array_integer_uint", + "required_double_array_integer_uint32", + "required_double_array_integer_uint64", "required_double_array_integer_unix", "required_double_array_integer_unix-micro", "required_double_array_integer_unix-milli", @@ -2448,6 +2643,9 @@ "required_integer", "required_integer_int32", "required_integer_int64", + "required_integer_uint", + "required_integer_uint32", + "required_integer_uint64", "required_integer_unix", "required_integer_unix-micro", "required_integer_unix-milli", @@ -3069,16 +3267,16 @@ } } }, - "/test_request_integer_unix": { + "/test_request_integer_uint": { "post": { - "operationId": "test_request_integer_unix", + "operationId": "test_request_integer_uint", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix" + "format": "uint" } } } @@ -3090,16 +3288,16 @@ } } }, - "/test_request_integer_unix-micro": { + "/test_request_integer_uint32": { "post": { - "operationId": "test_request_integer_unix-micro", + "operationId": "test_request_integer_uint32", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix-micro" + "format": "uint32" } } } @@ -3111,9 +3309,9 @@ } } }, - "/test_request_integer_unix-micro_array": { + "/test_request_integer_uint32_array": { "post": { - "operationId": "test_request_integer_unix-micro_array", + "operationId": "test_request_integer_uint32_array", "requestBody": { "description": "Optional request body", "content": { @@ -3122,7 +3320,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-micro" + "format": "uint32" } } } @@ -3135,9 +3333,9 @@ } } }, - "/test_request_integer_unix-micro_array_array": { + "/test_request_integer_uint32_array_array": { "post": { - "operationId": "test_request_integer_unix-micro_array_array", + "operationId": "test_request_integer_uint32_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3148,7 +3346,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-micro" + "format": "uint32" } } } @@ -3162,16 +3360,16 @@ } } }, - "/test_request_integer_unix-micro_nullable": { + "/test_request_integer_uint32_nullable": { "post": { - "operationId": "test_request_integer_unix-micro_nullable", + "operationId": "test_request_integer_uint32_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix-micro", + "format": "uint32", "nullable": true } } @@ -3184,9 +3382,9 @@ } } }, - "/test_request_integer_unix-micro_nullable_array": { + "/test_request_integer_uint32_nullable_array": { "post": { - "operationId": "test_request_integer_unix-micro_nullable_array", + "operationId": "test_request_integer_uint32_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -3195,7 +3393,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-micro", + "format": "uint32", "nullable": true } } @@ -3209,9 +3407,9 @@ } } }, - "/test_request_integer_unix-micro_nullable_array_array": { + "/test_request_integer_uint32_nullable_array_array": { "post": { - "operationId": "test_request_integer_unix-micro_nullable_array_array", + "operationId": "test_request_integer_uint32_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3222,7 +3420,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-micro", + "format": "uint32", "nullable": true } } @@ -3237,16 +3435,16 @@ } } }, - "/test_request_integer_unix-milli": { + "/test_request_integer_uint64": { "post": { - "operationId": "test_request_integer_unix-milli", + "operationId": "test_request_integer_uint64", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix-milli" + "format": "uint64" } } } @@ -3258,9 +3456,9 @@ } } }, - "/test_request_integer_unix-milli_array": { + "/test_request_integer_uint64_array": { "post": { - "operationId": "test_request_integer_unix-milli_array", + "operationId": "test_request_integer_uint64_array", "requestBody": { "description": "Optional request body", "content": { @@ -3269,7 +3467,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-milli" + "format": "uint64" } } } @@ -3282,9 +3480,9 @@ } } }, - "/test_request_integer_unix-milli_array_array": { + "/test_request_integer_uint64_array_array": { "post": { - "operationId": "test_request_integer_unix-milli_array_array", + "operationId": "test_request_integer_uint64_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3295,7 +3493,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-milli" + "format": "uint64" } } } @@ -3309,16 +3507,16 @@ } } }, - "/test_request_integer_unix-milli_nullable": { + "/test_request_integer_uint64_nullable": { "post": { - "operationId": "test_request_integer_unix-milli_nullable", + "operationId": "test_request_integer_uint64_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix-milli", + "format": "uint64", "nullable": true } } @@ -3331,9 +3529,9 @@ } } }, - "/test_request_integer_unix-milli_nullable_array": { + "/test_request_integer_uint64_nullable_array": { "post": { - "operationId": "test_request_integer_unix-milli_nullable_array", + "operationId": "test_request_integer_uint64_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -3342,7 +3540,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-milli", + "format": "uint64", "nullable": true } } @@ -3356,9 +3554,9 @@ } } }, - "/test_request_integer_unix-milli_nullable_array_array": { + "/test_request_integer_uint64_nullable_array_array": { "post": { - "operationId": "test_request_integer_unix-milli_nullable_array_array", + "operationId": "test_request_integer_uint64_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3369,7 +3567,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-milli", + "format": "uint64", "nullable": true } } @@ -3384,30 +3582,9 @@ } } }, - "/test_request_integer_unix-nano": { - "post": { - "operationId": "test_request_integer_unix-nano", - "requestBody": { - "description": "Optional request body", - "content": { - "application/json": { - "schema": { - "type": "integer", - "format": "unix-nano" - } - } - } - }, - "responses": { - "200": { - "$ref": "#/components/responses/error" - } - } - } - }, - "/test_request_integer_unix-nano_array": { + "/test_request_integer_uint_array": { "post": { - "operationId": "test_request_integer_unix-nano_array", + "operationId": "test_request_integer_uint_array", "requestBody": { "description": "Optional request body", "content": { @@ -3416,7 +3593,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-nano" + "format": "uint" } } } @@ -3429,9 +3606,9 @@ } } }, - "/test_request_integer_unix-nano_array_array": { + "/test_request_integer_uint_array_array": { "post": { - "operationId": "test_request_integer_unix-nano_array_array", + "operationId": "test_request_integer_uint_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3442,7 +3619,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-nano" + "format": "uint" } } } @@ -3456,16 +3633,16 @@ } } }, - "/test_request_integer_unix-nano_nullable": { + "/test_request_integer_uint_nullable": { "post": { - "operationId": "test_request_integer_unix-nano_nullable", + "operationId": "test_request_integer_uint_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix-nano", + "format": "uint", "nullable": true } } @@ -3478,9 +3655,9 @@ } } }, - "/test_request_integer_unix-nano_nullable_array": { + "/test_request_integer_uint_nullable_array": { "post": { - "operationId": "test_request_integer_unix-nano_nullable_array", + "operationId": "test_request_integer_uint_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -3489,7 +3666,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-nano", + "format": "uint", "nullable": true } } @@ -3503,9 +3680,9 @@ } } }, - "/test_request_integer_unix-nano_nullable_array_array": { + "/test_request_integer_uint_nullable_array_array": { "post": { - "operationId": "test_request_integer_unix-nano_nullable_array_array", + "operationId": "test_request_integer_uint_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3516,7 +3693,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-nano", + "format": "uint", "nullable": true } } @@ -3531,16 +3708,16 @@ } } }, - "/test_request_integer_unix-seconds": { + "/test_request_integer_unix": { "post": { - "operationId": "test_request_integer_unix-seconds", + "operationId": "test_request_integer_unix", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix-seconds" + "format": "unix" } } } @@ -3552,9 +3729,30 @@ } } }, - "/test_request_integer_unix-seconds_array": { + "/test_request_integer_unix-micro": { "post": { - "operationId": "test_request_integer_unix-seconds_array", + "operationId": "test_request_integer_unix-micro", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "unix-micro" + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_integer_unix-micro_array": { + "post": { + "operationId": "test_request_integer_unix-micro_array", "requestBody": { "description": "Optional request body", "content": { @@ -3563,7 +3761,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-seconds" + "format": "unix-micro" } } } @@ -3576,9 +3774,9 @@ } } }, - "/test_request_integer_unix-seconds_array_array": { + "/test_request_integer_unix-micro_array_array": { "post": { - "operationId": "test_request_integer_unix-seconds_array_array", + "operationId": "test_request_integer_unix-micro_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3589,7 +3787,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-seconds" + "format": "unix-micro" } } } @@ -3603,16 +3801,16 @@ } } }, - "/test_request_integer_unix-seconds_nullable": { + "/test_request_integer_unix-micro_nullable": { "post": { - "operationId": "test_request_integer_unix-seconds_nullable", + "operationId": "test_request_integer_unix-micro_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix-seconds", + "format": "unix-micro", "nullable": true } } @@ -3625,9 +3823,9 @@ } } }, - "/test_request_integer_unix-seconds_nullable_array": { + "/test_request_integer_unix-micro_nullable_array": { "post": { - "operationId": "test_request_integer_unix-seconds_nullable_array", + "operationId": "test_request_integer_unix-micro_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -3636,7 +3834,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-seconds", + "format": "unix-micro", "nullable": true } } @@ -3650,9 +3848,9 @@ } } }, - "/test_request_integer_unix-seconds_nullable_array_array": { + "/test_request_integer_unix-micro_nullable_array_array": { "post": { - "operationId": "test_request_integer_unix-seconds_nullable_array_array", + "operationId": "test_request_integer_unix-micro_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3663,7 +3861,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix-seconds", + "format": "unix-micro", "nullable": true } } @@ -3678,9 +3876,30 @@ } } }, - "/test_request_integer_unix_array": { + "/test_request_integer_unix-milli": { "post": { - "operationId": "test_request_integer_unix_array", + "operationId": "test_request_integer_unix-milli", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "unix-milli" + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_integer_unix-milli_array": { + "post": { + "operationId": "test_request_integer_unix-milli_array", "requestBody": { "description": "Optional request body", "content": { @@ -3689,7 +3908,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix" + "format": "unix-milli" } } } @@ -3702,9 +3921,9 @@ } } }, - "/test_request_integer_unix_array_array": { + "/test_request_integer_unix-milli_array_array": { "post": { - "operationId": "test_request_integer_unix_array_array", + "operationId": "test_request_integer_unix-milli_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3715,7 +3934,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix" + "format": "unix-milli" } } } @@ -3729,16 +3948,16 @@ } } }, - "/test_request_integer_unix_nullable": { + "/test_request_integer_unix-milli_nullable": { "post": { - "operationId": "test_request_integer_unix_nullable", + "operationId": "test_request_integer_unix-milli_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "unix", + "format": "unix-milli", "nullable": true } } @@ -3751,9 +3970,9 @@ } } }, - "/test_request_integer_unix_nullable_array": { + "/test_request_integer_unix-milli_nullable_array": { "post": { - "operationId": "test_request_integer_unix_nullable_array", + "operationId": "test_request_integer_unix-milli_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -3762,7 +3981,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix", + "format": "unix-milli", "nullable": true } } @@ -3776,9 +3995,9 @@ } } }, - "/test_request_integer_unix_nullable_array_array": { + "/test_request_integer_unix-milli_nullable_array_array": { "post": { - "operationId": "test_request_integer_unix_nullable_array_array", + "operationId": "test_request_integer_unix-milli_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3789,7 +4008,7 @@ "type": "array", "items": { "type": "integer", - "format": "unix", + "format": "unix-milli", "nullable": true } } @@ -3804,15 +4023,16 @@ } } }, - "/test_request_null": { + "/test_request_integer_unix-nano": { "post": { - "operationId": "test_request_null", + "operationId": "test_request_integer_unix-nano", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "null" + "type": "integer", + "format": "unix-nano" } } } @@ -3824,9 +4044,9 @@ } } }, - "/test_request_null_array": { + "/test_request_integer_unix-nano_array": { "post": { - "operationId": "test_request_null_array", + "operationId": "test_request_integer_unix-nano_array", "requestBody": { "description": "Optional request body", "content": { @@ -3834,7 +4054,8 @@ "schema": { "type": "array", "items": { - "type": "null" + "type": "integer", + "format": "unix-nano" } } } @@ -3847,9 +4068,9 @@ } } }, - "/test_request_null_array_array": { + "/test_request_integer_unix-nano_array_array": { "post": { - "operationId": "test_request_null_array_array", + "operationId": "test_request_integer_unix-nano_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3859,7 +4080,8 @@ "items": { "type": "array", "items": { - "type": "null" + "type": "integer", + "format": "unix-nano" } } } @@ -3873,15 +4095,16 @@ } } }, - "/test_request_null_nullable": { + "/test_request_integer_unix-nano_nullable": { "post": { - "operationId": "test_request_null_nullable", + "operationId": "test_request_integer_unix-nano_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "null", + "type": "integer", + "format": "unix-nano", "nullable": true } } @@ -3894,9 +4117,9 @@ } } }, - "/test_request_null_nullable_array": { + "/test_request_integer_unix-nano_nullable_array": { "post": { - "operationId": "test_request_null_nullable_array", + "operationId": "test_request_integer_unix-nano_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -3904,7 +4127,8 @@ "schema": { "type": "array", "items": { - "type": "null", + "type": "integer", + "format": "unix-nano", "nullable": true } } @@ -3918,9 +4142,9 @@ } } }, - "/test_request_null_nullable_array_array": { + "/test_request_integer_unix-nano_nullable_array_array": { "post": { - "operationId": "test_request_null_nullable_array_array", + "operationId": "test_request_integer_unix-nano_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -3930,7 +4154,8 @@ "items": { "type": "array", "items": { - "type": "null", + "type": "integer", + "format": "unix-nano", "nullable": true } } @@ -3945,15 +4170,16 @@ } } }, - "/test_request_number": { + "/test_request_integer_unix-seconds": { "post": { - "operationId": "test_request_number", + "operationId": "test_request_integer_unix-seconds", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "number" + "type": "integer", + "format": "unix-seconds" } } } @@ -3965,9 +4191,9 @@ } } }, - "/test_request_number_array": { + "/test_request_integer_unix-seconds_array": { "post": { - "operationId": "test_request_number_array", + "operationId": "test_request_integer_unix-seconds_array", "requestBody": { "description": "Optional request body", "content": { @@ -3975,7 +4201,8 @@ "schema": { "type": "array", "items": { - "type": "number" + "type": "integer", + "format": "unix-seconds" } } } @@ -3988,9 +4215,9 @@ } } }, - "/test_request_number_array_array": { + "/test_request_integer_unix-seconds_array_array": { "post": { - "operationId": "test_request_number_array_array", + "operationId": "test_request_integer_unix-seconds_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4000,7 +4227,8 @@ "items": { "type": "array", "items": { - "type": "number" + "type": "integer", + "format": "unix-seconds" } } } @@ -4014,16 +4242,17 @@ } } }, - "/test_request_number_double": { + "/test_request_integer_unix-seconds_nullable": { "post": { - "operationId": "test_request_number_double", + "operationId": "test_request_integer_unix-seconds_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "number", - "format": "double" + "type": "integer", + "format": "unix-seconds", + "nullable": true } } } @@ -4035,9 +4264,9 @@ } } }, - "/test_request_number_double_array": { + "/test_request_integer_unix-seconds_nullable_array": { "post": { - "operationId": "test_request_number_double_array", + "operationId": "test_request_integer_unix-seconds_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -4045,8 +4274,9 @@ "schema": { "type": "array", "items": { - "type": "number", - "format": "double" + "type": "integer", + "format": "unix-seconds", + "nullable": true } } } @@ -4059,9 +4289,9 @@ } } }, - "/test_request_number_double_array_array": { + "/test_request_integer_unix-seconds_nullable_array_array": { "post": { - "operationId": "test_request_number_double_array_array", + "operationId": "test_request_integer_unix-seconds_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4071,8 +4301,9 @@ "items": { "type": "array", "items": { - "type": "number", - "format": "double" + "type": "integer", + "format": "unix-seconds", + "nullable": true } } } @@ -4086,31 +4317,9 @@ } } }, - "/test_request_number_double_nullable": { - "post": { - "operationId": "test_request_number_double_nullable", - "requestBody": { - "description": "Optional request body", - "content": { - "application/json": { - "schema": { - "type": "number", - "format": "double", - "nullable": true - } - } - } - }, - "responses": { - "200": { - "$ref": "#/components/responses/error" - } - } - } - }, - "/test_request_number_double_nullable_array": { + "/test_request_integer_unix_array": { "post": { - "operationId": "test_request_number_double_nullable_array", + "operationId": "test_request_integer_unix_array", "requestBody": { "description": "Optional request body", "content": { @@ -4118,9 +4327,8 @@ "schema": { "type": "array", "items": { - "type": "number", - "format": "double", - "nullable": true + "type": "integer", + "format": "unix" } } } @@ -4133,9 +4341,9 @@ } } }, - "/test_request_number_double_nullable_array_array": { + "/test_request_integer_unix_array_array": { "post": { - "operationId": "test_request_number_double_nullable_array_array", + "operationId": "test_request_integer_unix_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4145,9 +4353,8 @@ "items": { "type": "array", "items": { - "type": "number", - "format": "double", - "nullable": true + "type": "integer", + "format": "unix" } } } @@ -4161,16 +4368,17 @@ } } }, - "/test_request_number_float": { + "/test_request_integer_unix_nullable": { "post": { - "operationId": "test_request_number_float", + "operationId": "test_request_integer_unix_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "number", - "format": "float" + "type": "integer", + "format": "unix", + "nullable": true } } } @@ -4182,9 +4390,9 @@ } } }, - "/test_request_number_float_array": { + "/test_request_integer_unix_nullable_array": { "post": { - "operationId": "test_request_number_float_array", + "operationId": "test_request_integer_unix_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -4192,8 +4400,9 @@ "schema": { "type": "array", "items": { - "type": "number", - "format": "float" + "type": "integer", + "format": "unix", + "nullable": true } } } @@ -4206,9 +4415,9 @@ } } }, - "/test_request_number_float_array_array": { + "/test_request_integer_unix_nullable_array_array": { "post": { - "operationId": "test_request_number_float_array_array", + "operationId": "test_request_integer_unix_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4218,8 +4427,9 @@ "items": { "type": "array", "items": { - "type": "number", - "format": "float" + "type": "integer", + "format": "unix", + "nullable": true } } } @@ -4233,17 +4443,15 @@ } } }, - "/test_request_number_float_nullable": { + "/test_request_null": { "post": { - "operationId": "test_request_number_float_nullable", + "operationId": "test_request_null", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "number", - "format": "float", - "nullable": true + "type": "null" } } } @@ -4255,9 +4463,9 @@ } } }, - "/test_request_number_float_nullable_array": { + "/test_request_null_array": { "post": { - "operationId": "test_request_number_float_nullable_array", + "operationId": "test_request_null_array", "requestBody": { "description": "Optional request body", "content": { @@ -4265,9 +4473,7 @@ "schema": { "type": "array", "items": { - "type": "number", - "format": "float", - "nullable": true + "type": "null" } } } @@ -4280,9 +4486,9 @@ } } }, - "/test_request_number_float_nullable_array_array": { + "/test_request_null_array_array": { "post": { - "operationId": "test_request_number_float_nullable_array_array", + "operationId": "test_request_null_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4292,9 +4498,7 @@ "items": { "type": "array", "items": { - "type": "number", - "format": "float", - "nullable": true + "type": "null" } } } @@ -4308,17 +4512,17 @@ } } }, - "/test_request_number_int32": { + "/test_request_null_nullable": { "post": { - "operationId": "test_request_number_int32", + "operationId": "test_request_null_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "number", - "format": "int32" - } + "type": "null", + "nullable": true + } } } }, @@ -4329,9 +4533,9 @@ } } }, - "/test_request_number_int32_array": { + "/test_request_null_nullable_array": { "post": { - "operationId": "test_request_number_int32_array", + "operationId": "test_request_null_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -4339,8 +4543,8 @@ "schema": { "type": "array", "items": { - "type": "number", - "format": "int32" + "type": "null", + "nullable": true } } } @@ -4353,9 +4557,9 @@ } } }, - "/test_request_number_int32_array_array": { + "/test_request_null_nullable_array_array": { "post": { - "operationId": "test_request_number_int32_array_array", + "operationId": "test_request_null_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4365,8 +4569,8 @@ "items": { "type": "array", "items": { - "type": "number", - "format": "int32" + "type": "null", + "nullable": true } } } @@ -4380,17 +4584,15 @@ } } }, - "/test_request_number_int32_nullable": { + "/test_request_number": { "post": { - "operationId": "test_request_number_int32_nullable", + "operationId": "test_request_number", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "number", - "format": "int32", - "nullable": true + "type": "number" } } } @@ -4402,9 +4604,9 @@ } } }, - "/test_request_number_int32_nullable_array": { + "/test_request_number_array": { "post": { - "operationId": "test_request_number_int32_nullable_array", + "operationId": "test_request_number_array", "requestBody": { "description": "Optional request body", "content": { @@ -4412,9 +4614,7 @@ "schema": { "type": "array", "items": { - "type": "number", - "format": "int32", - "nullable": true + "type": "number" } } } @@ -4427,9 +4627,9 @@ } } }, - "/test_request_number_int32_nullable_array_array": { + "/test_request_number_array_array": { "post": { - "operationId": "test_request_number_int32_nullable_array_array", + "operationId": "test_request_number_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4439,9 +4639,7 @@ "items": { "type": "array", "items": { - "type": "number", - "format": "int32", - "nullable": true + "type": "number" } } } @@ -4455,16 +4653,16 @@ } } }, - "/test_request_number_int64": { + "/test_request_number_double": { "post": { - "operationId": "test_request_number_int64", + "operationId": "test_request_number_double", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "number", - "format": "int64" + "format": "double" } } } @@ -4476,9 +4674,9 @@ } } }, - "/test_request_number_int64_array": { + "/test_request_number_double_array": { "post": { - "operationId": "test_request_number_int64_array", + "operationId": "test_request_number_double_array", "requestBody": { "description": "Optional request body", "content": { @@ -4487,7 +4685,7 @@ "type": "array", "items": { "type": "number", - "format": "int64" + "format": "double" } } } @@ -4500,9 +4698,9 @@ } } }, - "/test_request_number_int64_array_array": { + "/test_request_number_double_array_array": { "post": { - "operationId": "test_request_number_int64_array_array", + "operationId": "test_request_number_double_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4513,7 +4711,7 @@ "type": "array", "items": { "type": "number", - "format": "int64" + "format": "double" } } } @@ -4527,16 +4725,16 @@ } } }, - "/test_request_number_int64_nullable": { + "/test_request_number_double_nullable": { "post": { - "operationId": "test_request_number_int64_nullable", + "operationId": "test_request_number_double_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "number", - "format": "int64", + "format": "double", "nullable": true } } @@ -4549,9 +4747,9 @@ } } }, - "/test_request_number_int64_nullable_array": { + "/test_request_number_double_nullable_array": { "post": { - "operationId": "test_request_number_int64_nullable_array", + "operationId": "test_request_number_double_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -4560,7 +4758,7 @@ "type": "array", "items": { "type": "number", - "format": "int64", + "format": "double", "nullable": true } } @@ -4574,9 +4772,9 @@ } } }, - "/test_request_number_int64_nullable_array_array": { + "/test_request_number_double_nullable_array_array": { "post": { - "operationId": "test_request_number_int64_nullable_array_array", + "operationId": "test_request_number_double_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4587,7 +4785,7 @@ "type": "array", "items": { "type": "number", - "format": "int64", + "format": "double", "nullable": true } } @@ -4602,15 +4800,88 @@ } } }, - "/test_request_number_nullable": { + "/test_request_number_float": { "post": { - "operationId": "test_request_number_nullable", + "operationId": "test_request_number_float", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "number", + "format": "float" + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_float_array": { + "post": { + "operationId": "test_request_number_float_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "number", + "format": "float" + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_float_array_array": { + "post": { + "operationId": "test_request_number_float_array_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "number", + "format": "float" + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_float_nullable": { + "post": { + "operationId": "test_request_number_float_nullable", "requestBody": { "description": "Optional request body", "content": { "application/json": { "schema": { "type": "number", + "format": "float", "nullable": true } } @@ -4623,9 +4894,9 @@ } } }, - "/test_request_number_nullable_array": { + "/test_request_number_float_nullable_array": { "post": { - "operationId": "test_request_number_nullable_array", + "operationId": "test_request_number_float_nullable_array", "requestBody": { "description": "Optional request body", "content": { @@ -4634,6 +4905,7 @@ "type": "array", "items": { "type": "number", + "format": "float", "nullable": true } } @@ -4647,9 +4919,9 @@ } } }, - "/test_request_number_nullable_array_array": { + "/test_request_number_float_nullable_array_array": { "post": { - "operationId": "test_request_number_nullable_array_array", + "operationId": "test_request_number_float_nullable_array_array", "requestBody": { "description": "Optional request body", "content": { @@ -4660,6 +4932,7 @@ "type": "array", "items": { "type": "number", + "format": "float", "nullable": true } } @@ -4674,17 +4947,19 @@ } } }, - "/test_request_required_Any": { + "/test_request_number_int32": { "post": { - "operationId": "test_request_required_Any", + "operationId": "test_request_number_int32", "requestBody": { - "description": "Required request body", + "description": "Optional request body", "content": { "application/json": { - "schema": {} + "schema": { + "type": "number", + "format": "int32" + } } - }, - "required": true + } }, "responses": { "200": { @@ -4693,19 +4968,22 @@ } } }, - "/test_request_required_EmptyStruct": { + "/test_request_number_int32_array": { "post": { - "operationId": "test_request_required_EmptyStruct", + "operationId": "test_request_number_int32_array", "requestBody": { - "description": "Required request body", + "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "object" + "type": "array", + "items": { + "type": "number", + "format": "int32" + } } } - }, - "required": true + } }, "responses": { "200": { @@ -4714,69 +4992,451 @@ } } }, - "/test_request_required_FormatTest": { + "/test_request_number_int32_array_array": { "post": { - "operationId": "test_request_required_FormatTest", + "operationId": "test_request_number_int32_array_array", "requestBody": { - "description": "Required request body", + "description": "Optional request body", "content": { "application/json": { "schema": { - "type": "object", - "properties": { - "required_any": {}, - "required_array_any": { - "type": "array", - "items": {} - }, - "required_array_boolean": { - "type": "array", - "items": { - "type": "boolean" - } - }, - "required_array_integer": { - "type": "array", - "items": { - "type": "integer" - } - }, - "required_array_integer_int32": { - "type": "array", - "items": { - "type": "integer", - "format": "int32" - } - }, - "required_array_integer_int64": { - "type": "array", - "items": { - "type": "integer", - "format": "int64" - } - }, - "required_array_integer_unix": { - "type": "array", - "items": { - "type": "integer", - "format": "unix" - } - }, - "required_array_integer_unix-micro": { - "type": "array", - "items": { - "type": "integer", - "format": "unix-micro" - } - }, - "required_array_integer_unix-milli": { - "type": "array", - "items": { - "type": "integer", - "format": "unix-milli" - } - }, - "required_array_integer_unix-nano": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "number", + "format": "int32" + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int32_nullable": { + "post": { + "operationId": "test_request_number_int32_nullable", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "number", + "format": "int32", + "nullable": true + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int32_nullable_array": { + "post": { + "operationId": "test_request_number_int32_nullable_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "number", + "format": "int32", + "nullable": true + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int32_nullable_array_array": { + "post": { + "operationId": "test_request_number_int32_nullable_array_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "number", + "format": "int32", + "nullable": true + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int64": { + "post": { + "operationId": "test_request_number_int64", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "number", + "format": "int64" + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int64_array": { + "post": { + "operationId": "test_request_number_int64_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "number", + "format": "int64" + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int64_array_array": { + "post": { + "operationId": "test_request_number_int64_array_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "number", + "format": "int64" + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int64_nullable": { + "post": { + "operationId": "test_request_number_int64_nullable", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "number", + "format": "int64", + "nullable": true + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int64_nullable_array": { + "post": { + "operationId": "test_request_number_int64_nullable_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "number", + "format": "int64", + "nullable": true + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_int64_nullable_array_array": { + "post": { + "operationId": "test_request_number_int64_nullable_array_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "number", + "format": "int64", + "nullable": true + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_nullable": { + "post": { + "operationId": "test_request_number_nullable", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "number", + "nullable": true + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_nullable_array": { + "post": { + "operationId": "test_request_number_nullable_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "number", + "nullable": true + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_number_nullable_array_array": { + "post": { + "operationId": "test_request_number_nullable_array_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "number", + "nullable": true + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_Any": { + "post": { + "operationId": "test_request_required_Any", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": {} + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_EmptyStruct": { + "post": { + "operationId": "test_request_required_EmptyStruct", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "object" + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_FormatTest": { + "post": { + "operationId": "test_request_required_FormatTest", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "object", + "properties": { + "required_any": {}, + "required_array_any": { + "type": "array", + "items": {} + }, + "required_array_boolean": { + "type": "array", + "items": { + "type": "boolean" + } + }, + "required_array_integer": { + "type": "array", + "items": { + "type": "integer" + } + }, + "required_array_integer_int32": { + "type": "array", + "items": { + "type": "integer", + "format": "int32" + } + }, + "required_array_integer_int64": { + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + }, + "required_array_integer_uint": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + }, + "required_array_integer_uint32": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + }, + "required_array_integer_uint64": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + }, + "required_array_integer_unix": { + "type": "array", + "items": { + "type": "integer", + "format": "unix" + } + }, + "required_array_integer_unix-micro": { + "type": "array", + "items": { + "type": "integer", + "format": "unix-micro" + } + }, + "required_array_integer_unix-milli": { + "type": "array", + "items": { + "type": "integer", + "format": "unix-milli" + } + }, + "required_array_integer_unix-nano": { "type": "array", "items": { "type": "integer", @@ -5031,6 +5691,36 @@ } } }, + "required_double_array_integer_uint": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + }, + "required_double_array_integer_uint32": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + } + }, + "required_double_array_integer_uint64": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + } + }, "required_double_array_integer_unix": { "type": "array", "items": { @@ -5369,6 +6059,18 @@ "type": "integer", "format": "int64" }, + "required_integer_uint": { + "type": "integer", + "format": "uint" + }, + "required_integer_uint32": { + "type": "integer", + "format": "uint32" + }, + "required_integer_uint64": { + "type": "integer", + "format": "uint64" + }, "required_integer_unix": { "type": "integer", "format": "unix" @@ -5529,6 +6231,27 @@ "format": "int64" } }, + "optional_array_integer_uint": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + }, + "optional_array_integer_uint32": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + }, + "optional_array_integer_uint64": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + }, "optional_array_integer_unix": { "type": "array", "items": { @@ -5805,6 +6528,36 @@ } } }, + "optional_double_array_integer_uint": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + }, + "optional_double_array_integer_uint32": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + } + }, + "optional_double_array_integer_uint64": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + } + }, "optional_double_array_integer_unix": { "type": "array", "items": { @@ -6122,273 +6875,588 @@ } } }, - "optional_double_array_string_uuid": { - "type": "array", - "items": { - "type": "array", - "items": { - "type": "string", - "format": "uuid" - } - } + "optional_double_array_string_uuid": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "uuid" + } + } + }, + "optional_integer": { + "type": "integer" + }, + "optional_integer_int32": { + "type": "integer", + "format": "int32" + }, + "optional_integer_int64": { + "type": "integer", + "format": "int64" + }, + "optional_integer_uint": { + "type": "integer", + "format": "uint" + }, + "optional_integer_uint32": { + "type": "integer", + "format": "uint32" + }, + "optional_integer_uint64": { + "type": "integer", + "format": "uint64" + }, + "optional_integer_unix": { + "type": "integer", + "format": "unix" + }, + "optional_integer_unix-micro": { + "type": "integer", + "format": "unix-micro" + }, + "optional_integer_unix-milli": { + "type": "integer", + "format": "unix-milli" + }, + "optional_integer_unix-nano": { + "type": "integer", + "format": "unix-nano" + }, + "optional_integer_unix-seconds": { + "type": "integer", + "format": "unix-seconds" + }, + "optional_null": { + "type": "null" + }, + "optional_number": { + "type": "number" + }, + "optional_number_double": { + "type": "number", + "format": "double" + }, + "optional_number_float": { + "type": "number", + "format": "float" + }, + "optional_number_int32": { + "type": "number", + "format": "int32" + }, + "optional_number_int64": { + "type": "number", + "format": "int64" + }, + "optional_string": { + "type": "string" + }, + "optional_string_binary": { + "type": "string", + "format": "binary" + }, + "optional_string_byte": { + "type": "string", + "format": "byte" + }, + "optional_string_date": { + "type": "string", + "format": "date" + }, + "optional_string_date-time": { + "type": "string", + "format": "date-time" + }, + "optional_string_duration": { + "type": "string", + "format": "duration" + }, + "optional_string_email": { + "type": "string", + "format": "email" + }, + "optional_string_hostname": { + "type": "string", + "format": "hostname" + }, + "optional_string_int32": { + "type": "string", + "format": "int32" + }, + "optional_string_int64": { + "type": "string", + "format": "int64" + }, + "optional_string_ip": { + "type": "string", + "format": "ip" + }, + "optional_string_ipv4": { + "type": "string", + "format": "ipv4" + }, + "optional_string_ipv6": { + "type": "string", + "format": "ipv6" + }, + "optional_string_password": { + "type": "string", + "format": "password" + }, + "optional_string_time": { + "type": "string", + "format": "time" + }, + "optional_string_unix": { + "type": "string", + "format": "unix" + }, + "optional_string_unix-micro": { + "type": "string", + "format": "unix-micro" + }, + "optional_string_unix-milli": { + "type": "string", + "format": "unix-milli" + }, + "optional_string_unix-nano": { + "type": "string", + "format": "unix-nano" }, - "optional_integer": { + "optional_string_unix-seconds": { + "type": "string", + "format": "unix-seconds" + }, + "optional_string_uri": { + "type": "string", + "format": "uri" + }, + "optional_string_uuid": { + "type": "string", + "format": "uuid" + } + }, + "required": [ + "required_any", + "required_array_any", + "required_array_boolean", + "required_array_integer", + "required_array_integer_int32", + "required_array_integer_int64", + "required_array_integer_uint", + "required_array_integer_uint32", + "required_array_integer_uint64", + "required_array_integer_unix", + "required_array_integer_unix-micro", + "required_array_integer_unix-milli", + "required_array_integer_unix-nano", + "required_array_integer_unix-seconds", + "required_array_null", + "required_array_number", + "required_array_number_double", + "required_array_number_float", + "required_array_number_int32", + "required_array_number_int64", + "required_array_string", + "required_array_string_binary", + "required_array_string_byte", + "required_array_string_date", + "required_array_string_date-time", + "required_array_string_duration", + "required_array_string_email", + "required_array_string_hostname", + "required_array_string_int32", + "required_array_string_int64", + "required_array_string_ip", + "required_array_string_ipv4", + "required_array_string_ipv6", + "required_array_string_password", + "required_array_string_time", + "required_array_string_unix", + "required_array_string_unix-micro", + "required_array_string_unix-milli", + "required_array_string_unix-nano", + "required_array_string_unix-seconds", + "required_array_string_uri", + "required_array_string_uuid", + "required_boolean", + "required_double_array_any", + "required_double_array_boolean", + "required_double_array_integer", + "required_double_array_integer_int32", + "required_double_array_integer_int64", + "required_double_array_integer_uint", + "required_double_array_integer_uint32", + "required_double_array_integer_uint64", + "required_double_array_integer_unix", + "required_double_array_integer_unix-micro", + "required_double_array_integer_unix-milli", + "required_double_array_integer_unix-nano", + "required_double_array_integer_unix-seconds", + "required_double_array_null", + "required_double_array_number", + "required_double_array_number_double", + "required_double_array_number_float", + "required_double_array_number_int32", + "required_double_array_number_int64", + "required_double_array_string", + "required_double_array_string_binary", + "required_double_array_string_byte", + "required_double_array_string_date", + "required_double_array_string_date-time", + "required_double_array_string_duration", + "required_double_array_string_email", + "required_double_array_string_hostname", + "required_double_array_string_int32", + "required_double_array_string_int64", + "required_double_array_string_ip", + "required_double_array_string_ipv4", + "required_double_array_string_ipv6", + "required_double_array_string_password", + "required_double_array_string_time", + "required_double_array_string_unix", + "required_double_array_string_unix-micro", + "required_double_array_string_unix-milli", + "required_double_array_string_unix-nano", + "required_double_array_string_unix-seconds", + "required_double_array_string_uri", + "required_double_array_string_uuid", + "required_integer", + "required_integer_int32", + "required_integer_int64", + "required_integer_uint", + "required_integer_uint32", + "required_integer_uint64", + "required_integer_unix", + "required_integer_unix-micro", + "required_integer_unix-milli", + "required_integer_unix-nano", + "required_integer_unix-seconds", + "required_null", + "required_number", + "required_number_double", + "required_number_float", + "required_number_int32", + "required_number_int64", + "required_string", + "required_string_binary", + "required_string_byte", + "required_string_date", + "required_string_date-time", + "required_string_duration", + "required_string_email", + "required_string_hostname", + "required_string_int32", + "required_string_int64", + "required_string_ip", + "required_string_ipv4", + "required_string_ipv6", + "required_string_password", + "required_string_time", + "required_string_unix", + "required_string_unix-micro", + "required_string_unix-milli", + "required_string_unix-nano", + "required_string_unix-seconds", + "required_string_uri", + "required_string_uuid" + ] + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_boolean": { + "post": { + "operationId": "test_request_required_boolean", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "boolean" + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_boolean_array": { + "post": { + "operationId": "test_request_required_boolean_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "boolean" + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_boolean_array_array": { + "post": { + "operationId": "test_request_required_boolean_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "boolean" + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_boolean_nullable": { + "post": { + "operationId": "test_request_required_boolean_nullable", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "boolean", + "nullable": true + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_boolean_nullable_array": { + "post": { + "operationId": "test_request_required_boolean_nullable_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "boolean", + "nullable": true + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_boolean_nullable_array_array": { + "post": { + "operationId": "test_request_required_boolean_nullable_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "boolean", + "nullable": true + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer": { + "post": { + "operationId": "test_request_required_integer", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "integer" + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_array": { + "post": { + "operationId": "test_request_required_integer_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer" + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_array_array": { + "post": { + "operationId": "test_request_required_integer_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { "type": "integer" - }, - "optional_integer_int32": { - "type": "integer", - "format": "int32" - }, - "optional_integer_int64": { - "type": "integer", - "format": "int64" - }, - "optional_integer_unix": { - "type": "integer", - "format": "unix" - }, - "optional_integer_unix-micro": { - "type": "integer", - "format": "unix-micro" - }, - "optional_integer_unix-milli": { - "type": "integer", - "format": "unix-milli" - }, - "optional_integer_unix-nano": { - "type": "integer", - "format": "unix-nano" - }, - "optional_integer_unix-seconds": { - "type": "integer", - "format": "unix-seconds" - }, - "optional_null": { - "type": "null" - }, - "optional_number": { - "type": "number" - }, - "optional_number_double": { - "type": "number", - "format": "double" - }, - "optional_number_float": { - "type": "number", - "format": "float" - }, - "optional_number_int32": { - "type": "number", - "format": "int32" - }, - "optional_number_int64": { - "type": "number", - "format": "int64" - }, - "optional_string": { - "type": "string" - }, - "optional_string_binary": { - "type": "string", - "format": "binary" - }, - "optional_string_byte": { - "type": "string", - "format": "byte" - }, - "optional_string_date": { - "type": "string", - "format": "date" - }, - "optional_string_date-time": { - "type": "string", - "format": "date-time" - }, - "optional_string_duration": { - "type": "string", - "format": "duration" - }, - "optional_string_email": { - "type": "string", - "format": "email" - }, - "optional_string_hostname": { - "type": "string", - "format": "hostname" - }, - "optional_string_int32": { - "type": "string", + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_int32": { + "post": { + "operationId": "test_request_required_integer_int32", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "int32" + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_int32_array": { + "post": { + "operationId": "test_request_required_integer_int32_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "int32" + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_int32_array_array": { + "post": { + "operationId": "test_request_required_integer_int32_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", "format": "int32" - }, - "optional_string_int64": { - "type": "string", - "format": "int64" - }, - "optional_string_ip": { - "type": "string", - "format": "ip" - }, - "optional_string_ipv4": { - "type": "string", - "format": "ipv4" - }, - "optional_string_ipv6": { - "type": "string", - "format": "ipv6" - }, - "optional_string_password": { - "type": "string", - "format": "password" - }, - "optional_string_time": { - "type": "string", - "format": "time" - }, - "optional_string_unix": { - "type": "string", - "format": "unix" - }, - "optional_string_unix-micro": { - "type": "string", - "format": "unix-micro" - }, - "optional_string_unix-milli": { - "type": "string", - "format": "unix-milli" - }, - "optional_string_unix-nano": { - "type": "string", - "format": "unix-nano" - }, - "optional_string_unix-seconds": { - "type": "string", - "format": "unix-seconds" - }, - "optional_string_uri": { - "type": "string", - "format": "uri" - }, - "optional_string_uuid": { - "type": "string", - "format": "uuid" } - }, - "required": [ - "required_any", - "required_array_any", - "required_array_boolean", - "required_array_integer", - "required_array_integer_int32", - "required_array_integer_int64", - "required_array_integer_unix", - "required_array_integer_unix-micro", - "required_array_integer_unix-milli", - "required_array_integer_unix-nano", - "required_array_integer_unix-seconds", - "required_array_null", - "required_array_number", - "required_array_number_double", - "required_array_number_float", - "required_array_number_int32", - "required_array_number_int64", - "required_array_string", - "required_array_string_binary", - "required_array_string_byte", - "required_array_string_date", - "required_array_string_date-time", - "required_array_string_duration", - "required_array_string_email", - "required_array_string_hostname", - "required_array_string_int32", - "required_array_string_int64", - "required_array_string_ip", - "required_array_string_ipv4", - "required_array_string_ipv6", - "required_array_string_password", - "required_array_string_time", - "required_array_string_unix", - "required_array_string_unix-micro", - "required_array_string_unix-milli", - "required_array_string_unix-nano", - "required_array_string_unix-seconds", - "required_array_string_uri", - "required_array_string_uuid", - "required_boolean", - "required_double_array_any", - "required_double_array_boolean", - "required_double_array_integer", - "required_double_array_integer_int32", - "required_double_array_integer_int64", - "required_double_array_integer_unix", - "required_double_array_integer_unix-micro", - "required_double_array_integer_unix-milli", - "required_double_array_integer_unix-nano", - "required_double_array_integer_unix-seconds", - "required_double_array_null", - "required_double_array_number", - "required_double_array_number_double", - "required_double_array_number_float", - "required_double_array_number_int32", - "required_double_array_number_int64", - "required_double_array_string", - "required_double_array_string_binary", - "required_double_array_string_byte", - "required_double_array_string_date", - "required_double_array_string_date-time", - "required_double_array_string_duration", - "required_double_array_string_email", - "required_double_array_string_hostname", - "required_double_array_string_int32", - "required_double_array_string_int64", - "required_double_array_string_ip", - "required_double_array_string_ipv4", - "required_double_array_string_ipv6", - "required_double_array_string_password", - "required_double_array_string_time", - "required_double_array_string_unix", - "required_double_array_string_unix-micro", - "required_double_array_string_unix-milli", - "required_double_array_string_unix-nano", - "required_double_array_string_unix-seconds", - "required_double_array_string_uri", - "required_double_array_string_uuid", - "required_integer", - "required_integer_int32", - "required_integer_int64", - "required_integer_unix", - "required_integer_unix-micro", - "required_integer_unix-milli", - "required_integer_unix-nano", - "required_integer_unix-seconds", - "required_null", - "required_number", - "required_number_double", - "required_number_float", - "required_number_int32", - "required_number_int64", - "required_string", - "required_string_binary", - "required_string_byte", - "required_string_date", - "required_string_date-time", - "required_string_duration", - "required_string_email", - "required_string_hostname", - "required_string_int32", - "required_string_int64", - "required_string_ip", - "required_string_ipv4", - "required_string_ipv6", - "required_string_password", - "required_string_time", - "required_string_unix", - "required_string_unix-micro", - "required_string_unix-milli", - "required_string_unix-nano", - "required_string_unix-seconds", - "required_string_uri", - "required_string_uuid" - ] + } } } }, @@ -6401,15 +7469,94 @@ } } }, - "/test_request_required_boolean": { + "/test_request_required_integer_int32_nullable": { + "post": { + "operationId": "test_request_required_integer_int32_nullable", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "int32", + "nullable": true + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_int32_nullable_array": { + "post": { + "operationId": "test_request_required_integer_int32_nullable_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "int32", + "nullable": true + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_int32_nullable_array_array": { + "post": { + "operationId": "test_request_required_integer_int32_nullable_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "int32", + "nullable": true + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_int64": { "post": { - "operationId": "test_request_required_boolean", + "operationId": "test_request_required_integer_int64", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { - "type": "boolean" + "type": "integer", + "format": "int64" } } }, @@ -6422,9 +7569,9 @@ } } }, - "/test_request_required_boolean_array": { + "/test_request_required_integer_int64_array": { "post": { - "operationId": "test_request_required_boolean_array", + "operationId": "test_request_required_integer_int64_array", "requestBody": { "description": "Required request body", "content": { @@ -6432,7 +7579,8 @@ "schema": { "type": "array", "items": { - "type": "boolean" + "type": "integer", + "format": "int64" } } } @@ -6446,9 +7594,9 @@ } } }, - "/test_request_required_boolean_array_array": { + "/test_request_required_integer_int64_array_array": { "post": { - "operationId": "test_request_required_boolean_array_array", + "operationId": "test_request_required_integer_int64_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6458,7 +7606,8 @@ "items": { "type": "array", "items": { - "type": "boolean" + "type": "integer", + "format": "int64" } } } @@ -6473,15 +7622,16 @@ } } }, - "/test_request_required_boolean_nullable": { + "/test_request_required_integer_int64_nullable": { "post": { - "operationId": "test_request_required_boolean_nullable", + "operationId": "test_request_required_integer_int64_nullable", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { - "type": "boolean", + "type": "integer", + "format": "int64", "nullable": true } } @@ -6495,9 +7645,9 @@ } } }, - "/test_request_required_boolean_nullable_array": { + "/test_request_required_integer_int64_nullable_array": { "post": { - "operationId": "test_request_required_boolean_nullable_array", + "operationId": "test_request_required_integer_int64_nullable_array", "requestBody": { "description": "Required request body", "content": { @@ -6505,7 +7655,8 @@ "schema": { "type": "array", "items": { - "type": "boolean", + "type": "integer", + "format": "int64", "nullable": true } } @@ -6520,9 +7671,9 @@ } } }, - "/test_request_required_boolean_nullable_array_array": { + "/test_request_required_integer_int64_nullable_array_array": { "post": { - "operationId": "test_request_required_boolean_nullable_array_array", + "operationId": "test_request_required_integer_int64_nullable_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6532,7 +7683,8 @@ "items": { "type": "array", "items": { - "type": "boolean", + "type": "integer", + "format": "int64", "nullable": true } } @@ -6548,15 +7700,16 @@ } } }, - "/test_request_required_integer": { + "/test_request_required_integer_nullable": { "post": { - "operationId": "test_request_required_integer", + "operationId": "test_request_required_integer_nullable", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { - "type": "integer" + "type": "integer", + "nullable": true } } }, @@ -6569,9 +7722,9 @@ } } }, - "/test_request_required_integer_array": { + "/test_request_required_integer_nullable_array": { "post": { - "operationId": "test_request_required_integer_array", + "operationId": "test_request_required_integer_nullable_array", "requestBody": { "description": "Required request body", "content": { @@ -6579,7 +7732,8 @@ "schema": { "type": "array", "items": { - "type": "integer" + "type": "integer", + "nullable": true } } } @@ -6593,9 +7747,9 @@ } } }, - "/test_request_required_integer_array_array": { + "/test_request_required_integer_nullable_array_array": { "post": { - "operationId": "test_request_required_integer_array_array", + "operationId": "test_request_required_integer_nullable_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6605,7 +7759,8 @@ "items": { "type": "array", "items": { - "type": "integer" + "type": "integer", + "nullable": true } } } @@ -6620,16 +7775,16 @@ } } }, - "/test_request_required_integer_int32": { + "/test_request_required_integer_uint": { "post": { - "operationId": "test_request_required_integer_int32", + "operationId": "test_request_required_integer_uint", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "int32" + "format": "uint" } } }, @@ -6642,9 +7797,31 @@ } } }, - "/test_request_required_integer_int32_array": { + "/test_request_required_integer_uint32": { "post": { - "operationId": "test_request_required_integer_int32_array", + "operationId": "test_request_required_integer_uint32", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "uint32" + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_uint32_array": { + "post": { + "operationId": "test_request_required_integer_uint32_array", "requestBody": { "description": "Required request body", "content": { @@ -6653,7 +7830,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32" + "format": "uint32" } } } @@ -6667,9 +7844,9 @@ } } }, - "/test_request_required_integer_int32_array_array": { + "/test_request_required_integer_uint32_array_array": { "post": { - "operationId": "test_request_required_integer_int32_array_array", + "operationId": "test_request_required_integer_uint32_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6680,7 +7857,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32" + "format": "uint32" } } } @@ -6695,16 +7872,16 @@ } } }, - "/test_request_required_integer_int32_nullable": { + "/test_request_required_integer_uint32_nullable": { "post": { - "operationId": "test_request_required_integer_int32_nullable", + "operationId": "test_request_required_integer_uint32_nullable", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "int32", + "format": "uint32", "nullable": true } } @@ -6718,9 +7895,9 @@ } } }, - "/test_request_required_integer_int32_nullable_array": { + "/test_request_required_integer_uint32_nullable_array": { "post": { - "operationId": "test_request_required_integer_int32_nullable_array", + "operationId": "test_request_required_integer_uint32_nullable_array", "requestBody": { "description": "Required request body", "content": { @@ -6729,7 +7906,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32", + "format": "uint32", "nullable": true } } @@ -6744,9 +7921,9 @@ } } }, - "/test_request_required_integer_int32_nullable_array_array": { + "/test_request_required_integer_uint32_nullable_array_array": { "post": { - "operationId": "test_request_required_integer_int32_nullable_array_array", + "operationId": "test_request_required_integer_uint32_nullable_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6757,7 +7934,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32", + "format": "uint32", "nullable": true } } @@ -6773,16 +7950,16 @@ } } }, - "/test_request_required_integer_int64": { + "/test_request_required_integer_uint64": { "post": { - "operationId": "test_request_required_integer_int64", + "operationId": "test_request_required_integer_uint64", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "int64" + "format": "uint64" } } }, @@ -6795,9 +7972,9 @@ } } }, - "/test_request_required_integer_int64_array": { + "/test_request_required_integer_uint64_array": { "post": { - "operationId": "test_request_required_integer_int64_array", + "operationId": "test_request_required_integer_uint64_array", "requestBody": { "description": "Required request body", "content": { @@ -6806,7 +7983,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64" + "format": "uint64" } } } @@ -6820,9 +7997,9 @@ } } }, - "/test_request_required_integer_int64_array_array": { + "/test_request_required_integer_uint64_array_array": { "post": { - "operationId": "test_request_required_integer_int64_array_array", + "operationId": "test_request_required_integer_uint64_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6833,7 +8010,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64" + "format": "uint64" } } } @@ -6848,16 +8025,16 @@ } } }, - "/test_request_required_integer_int64_nullable": { + "/test_request_required_integer_uint64_nullable": { "post": { - "operationId": "test_request_required_integer_int64_nullable", + "operationId": "test_request_required_integer_uint64_nullable", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { "type": "integer", - "format": "int64", + "format": "uint64", "nullable": true } } @@ -6871,9 +8048,9 @@ } } }, - "/test_request_required_integer_int64_nullable_array": { + "/test_request_required_integer_uint64_nullable_array": { "post": { - "operationId": "test_request_required_integer_int64_nullable_array", + "operationId": "test_request_required_integer_uint64_nullable_array", "requestBody": { "description": "Required request body", "content": { @@ -6882,7 +8059,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64", + "format": "uint64", "nullable": true } } @@ -6897,9 +8074,9 @@ } } }, - "/test_request_required_integer_int64_nullable_array_array": { + "/test_request_required_integer_uint64_nullable_array_array": { "post": { - "operationId": "test_request_required_integer_int64_nullable_array_array", + "operationId": "test_request_required_integer_uint64_nullable_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6910,7 +8087,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64", + "format": "uint64", "nullable": true } } @@ -6926,15 +8103,69 @@ } } }, - "/test_request_required_integer_nullable": { + "/test_request_required_integer_uint_array": { "post": { - "operationId": "test_request_required_integer_nullable", + "operationId": "test_request_required_integer_uint_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_uint_array_array": { + "post": { + "operationId": "test_request_required_integer_uint_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_integer_uint_nullable": { + "post": { + "operationId": "test_request_required_integer_uint_nullable", "requestBody": { "description": "Required request body", "content": { "application/json": { "schema": { "type": "integer", + "format": "uint", "nullable": true } } @@ -6948,9 +8179,9 @@ } } }, - "/test_request_required_integer_nullable_array": { + "/test_request_required_integer_uint_nullable_array": { "post": { - "operationId": "test_request_required_integer_nullable_array", + "operationId": "test_request_required_integer_uint_nullable_array", "requestBody": { "description": "Required request body", "content": { @@ -6959,6 +8190,7 @@ "type": "array", "items": { "type": "integer", + "format": "uint", "nullable": true } } @@ -6973,9 +8205,9 @@ } } }, - "/test_request_required_integer_nullable_array_array": { + "/test_request_required_integer_uint_nullable_array_array": { "post": { - "operationId": "test_request_required_integer_nullable_array_array", + "operationId": "test_request_required_integer_uint_nullable_array_array", "requestBody": { "description": "Required request body", "content": { @@ -6986,6 +8218,7 @@ "type": "array", "items": { "type": "integer", + "format": "uint", "nullable": true } } @@ -15343,6 +16576,27 @@ "format": "int64" } }, + "required_array_integer_uint": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + }, + "required_array_integer_uint32": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + }, + "required_array_integer_uint64": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + }, "required_array_integer_unix": { "type": "array", "items": { @@ -15619,6 +16873,36 @@ } } }, + "required_double_array_integer_uint": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + }, + "required_double_array_integer_uint32": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + } + }, + "required_double_array_integer_uint64": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + } + }, "required_double_array_integer_unix": { "type": "array", "items": { @@ -15957,6 +17241,18 @@ "type": "integer", "format": "int64" }, + "required_integer_uint": { + "type": "integer", + "format": "uint" + }, + "required_integer_uint32": { + "type": "integer", + "format": "uint32" + }, + "required_integer_uint64": { + "type": "integer", + "format": "uint64" + }, "required_integer_unix": { "type": "integer", "format": "unix" @@ -16117,6 +17413,27 @@ "format": "int64" } }, + "optional_array_integer_uint": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + }, + "optional_array_integer_uint32": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" + } + }, + "optional_array_integer_uint64": { + "type": "array", + "items": { + "type": "integer", + "format": "uint64" + } + }, "optional_array_integer_unix": { "type": "array", "items": { @@ -16379,17 +17696,47 @@ "type": "array", "items": { "type": "integer", - "format": "int32" + "format": "int32" + } + } + }, + "optional_double_array_integer_int64": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + } + }, + "optional_double_array_integer_uint": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + }, + "optional_double_array_integer_uint32": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint32" } } }, - "optional_double_array_integer_int64": { + "optional_double_array_integer_uint64": { "type": "array", "items": { "type": "array", "items": { "type": "integer", - "format": "int64" + "format": "uint64" } } }, @@ -16731,6 +18078,18 @@ "type": "integer", "format": "int64" }, + "optional_integer_uint": { + "type": "integer", + "format": "uint" + }, + "optional_integer_uint32": { + "type": "integer", + "format": "uint32" + }, + "optional_integer_uint64": { + "type": "integer", + "format": "uint64" + }, "optional_integer_unix": { "type": "integer", "format": "unix" @@ -16860,123 +18219,414 @@ "type": "string", "format": "uuid" } - }, - "required": [ - "required_any", - "required_array_any", - "required_array_boolean", - "required_array_integer", - "required_array_integer_int32", - "required_array_integer_int64", - "required_array_integer_unix", - "required_array_integer_unix-micro", - "required_array_integer_unix-milli", - "required_array_integer_unix-nano", - "required_array_integer_unix-seconds", - "required_array_null", - "required_array_number", - "required_array_number_double", - "required_array_number_float", - "required_array_number_int32", - "required_array_number_int64", - "required_array_string", - "required_array_string_binary", - "required_array_string_byte", - "required_array_string_date", - "required_array_string_date-time", - "required_array_string_duration", - "required_array_string_email", - "required_array_string_hostname", - "required_array_string_int32", - "required_array_string_int64", - "required_array_string_ip", - "required_array_string_ipv4", - "required_array_string_ipv6", - "required_array_string_password", - "required_array_string_time", - "required_array_string_unix", - "required_array_string_unix-micro", - "required_array_string_unix-milli", - "required_array_string_unix-nano", - "required_array_string_unix-seconds", - "required_array_string_uri", - "required_array_string_uuid", - "required_boolean", - "required_double_array_any", - "required_double_array_boolean", - "required_double_array_integer", - "required_double_array_integer_int32", - "required_double_array_integer_int64", - "required_double_array_integer_unix", - "required_double_array_integer_unix-micro", - "required_double_array_integer_unix-milli", - "required_double_array_integer_unix-nano", - "required_double_array_integer_unix-seconds", - "required_double_array_null", - "required_double_array_number", - "required_double_array_number_double", - "required_double_array_number_float", - "required_double_array_number_int32", - "required_double_array_number_int64", - "required_double_array_string", - "required_double_array_string_binary", - "required_double_array_string_byte", - "required_double_array_string_date", - "required_double_array_string_date-time", - "required_double_array_string_duration", - "required_double_array_string_email", - "required_double_array_string_hostname", - "required_double_array_string_int32", - "required_double_array_string_int64", - "required_double_array_string_ip", - "required_double_array_string_ipv4", - "required_double_array_string_ipv6", - "required_double_array_string_password", - "required_double_array_string_time", - "required_double_array_string_unix", - "required_double_array_string_unix-micro", - "required_double_array_string_unix-milli", - "required_double_array_string_unix-nano", - "required_double_array_string_unix-seconds", - "required_double_array_string_uri", - "required_double_array_string_uuid", - "required_integer", - "required_integer_int32", - "required_integer_int64", - "required_integer_unix", - "required_integer_unix-micro", - "required_integer_unix-milli", - "required_integer_unix-nano", - "required_integer_unix-seconds", - "required_null", - "required_number", - "required_number_double", - "required_number_float", - "required_number_int32", - "required_number_int64", - "required_string", - "required_string_binary", - "required_string_byte", - "required_string_date", - "required_string_date-time", - "required_string_duration", - "required_string_email", - "required_string_hostname", - "required_string_int32", - "required_string_int64", - "required_string_ip", - "required_string_ipv4", - "required_string_ipv6", - "required_string_password", - "required_string_time", - "required_string_unix", - "required_string_unix-micro", - "required_string_unix-milli", - "required_string_unix-nano", - "required_string_unix-seconds", - "required_string_uri", - "required_string_uuid" - ] + }, + "required": [ + "required_any", + "required_array_any", + "required_array_boolean", + "required_array_integer", + "required_array_integer_int32", + "required_array_integer_int64", + "required_array_integer_uint", + "required_array_integer_uint32", + "required_array_integer_uint64", + "required_array_integer_unix", + "required_array_integer_unix-micro", + "required_array_integer_unix-milli", + "required_array_integer_unix-nano", + "required_array_integer_unix-seconds", + "required_array_null", + "required_array_number", + "required_array_number_double", + "required_array_number_float", + "required_array_number_int32", + "required_array_number_int64", + "required_array_string", + "required_array_string_binary", + "required_array_string_byte", + "required_array_string_date", + "required_array_string_date-time", + "required_array_string_duration", + "required_array_string_email", + "required_array_string_hostname", + "required_array_string_int32", + "required_array_string_int64", + "required_array_string_ip", + "required_array_string_ipv4", + "required_array_string_ipv6", + "required_array_string_password", + "required_array_string_time", + "required_array_string_unix", + "required_array_string_unix-micro", + "required_array_string_unix-milli", + "required_array_string_unix-nano", + "required_array_string_unix-seconds", + "required_array_string_uri", + "required_array_string_uuid", + "required_boolean", + "required_double_array_any", + "required_double_array_boolean", + "required_double_array_integer", + "required_double_array_integer_int32", + "required_double_array_integer_int64", + "required_double_array_integer_uint", + "required_double_array_integer_uint32", + "required_double_array_integer_uint64", + "required_double_array_integer_unix", + "required_double_array_integer_unix-micro", + "required_double_array_integer_unix-milli", + "required_double_array_integer_unix-nano", + "required_double_array_integer_unix-seconds", + "required_double_array_null", + "required_double_array_number", + "required_double_array_number_double", + "required_double_array_number_float", + "required_double_array_number_int32", + "required_double_array_number_int64", + "required_double_array_string", + "required_double_array_string_binary", + "required_double_array_string_byte", + "required_double_array_string_date", + "required_double_array_string_date-time", + "required_double_array_string_duration", + "required_double_array_string_email", + "required_double_array_string_hostname", + "required_double_array_string_int32", + "required_double_array_string_int64", + "required_double_array_string_ip", + "required_double_array_string_ipv4", + "required_double_array_string_ipv6", + "required_double_array_string_password", + "required_double_array_string_time", + "required_double_array_string_unix", + "required_double_array_string_unix-micro", + "required_double_array_string_unix-milli", + "required_double_array_string_unix-nano", + "required_double_array_string_unix-seconds", + "required_double_array_string_uri", + "required_double_array_string_uuid", + "required_integer", + "required_integer_int32", + "required_integer_int64", + "required_integer_uint", + "required_integer_uint32", + "required_integer_uint64", + "required_integer_unix", + "required_integer_unix-micro", + "required_integer_unix-milli", + "required_integer_unix-nano", + "required_integer_unix-seconds", + "required_null", + "required_number", + "required_number_double", + "required_number_float", + "required_number_int32", + "required_number_int64", + "required_string", + "required_string_binary", + "required_string_byte", + "required_string_date", + "required_string_date-time", + "required_string_duration", + "required_string_email", + "required_string_hostname", + "required_string_int32", + "required_string_int64", + "required_string_ip", + "required_string_ipv4", + "required_string_ipv6", + "required_string_password", + "required_string_time", + "required_string_unix", + "required_string_unix-micro", + "required_string_unix-milli", + "required_string_unix-nano", + "required_string_unix-seconds", + "required_string_uri", + "required_string_uuid" + ] + } + } + } + } + } + } + }, + "/test_response_boolean": { + "post": { + "operationId": "test_response_boolean", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "boolean" + } + } + } + } + } + } + }, + "/test_response_boolean_array": { + "post": { + "operationId": "test_response_boolean_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "boolean" + } + } + } + } + } + } + } + }, + "/test_response_boolean_array_array": { + "post": { + "operationId": "test_response_boolean_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "boolean" + } + } + } + } + } + } + } + } + }, + "/test_response_boolean_nullable": { + "post": { + "operationId": "test_response_boolean_nullable", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "boolean", + "nullable": true + } + } + } + } + } + } + }, + "/test_response_boolean_nullable_array": { + "post": { + "operationId": "test_response_boolean_nullable_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "boolean", + "nullable": true + } + } + } + } + } + } + } + }, + "/test_response_boolean_nullable_array_array": { + "post": { + "operationId": "test_response_boolean_nullable_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "boolean", + "nullable": true + } + } + } + } + } + } + } + } + }, + "/test_response_integer": { + "post": { + "operationId": "test_response_integer", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "integer" + } + } + } + } + } + } + }, + "/test_response_integer_array": { + "post": { + "operationId": "test_response_integer_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer" + } + } + } + } + } + } + } + }, + "/test_response_integer_array_array": { + "post": { + "operationId": "test_response_integer_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer" + } + } + } + } + } + } + } + } + }, + "/test_response_integer_int32": { + "post": { + "operationId": "test_response_integer_int32", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "int32" + } + } + } + } + } + } + }, + "/test_response_integer_int32_array": { + "post": { + "operationId": "test_response_integer_int32_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "int32" + } + } + } + } + } + } + } + }, + "/test_response_integer_int32_array_array": { + "post": { + "operationId": "test_response_integer_int32_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "int32" + } + } } } } @@ -16984,9 +18634,9 @@ } } }, - "/test_response_boolean": { + "/test_response_integer_int32_nullable": { "post": { - "operationId": "test_response_boolean", + "operationId": "test_response_integer_int32_nullable", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -16996,7 +18646,9 @@ "content": { "application/json": { "schema": { - "type": "boolean" + "type": "integer", + "format": "int32", + "nullable": true } } } @@ -17004,9 +18656,9 @@ } } }, - "/test_response_boolean_array": { + "/test_response_integer_int32_nullable_array": { "post": { - "operationId": "test_response_boolean_array", + "operationId": "test_response_integer_int32_nullable_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17018,7 +18670,9 @@ "schema": { "type": "array", "items": { - "type": "boolean" + "type": "integer", + "format": "int32", + "nullable": true } } } @@ -17027,9 +18681,9 @@ } } }, - "/test_response_boolean_array_array": { + "/test_response_integer_int32_nullable_array_array": { "post": { - "operationId": "test_response_boolean_array_array", + "operationId": "test_response_integer_int32_nullable_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17043,7 +18697,9 @@ "items": { "type": "array", "items": { - "type": "boolean" + "type": "integer", + "format": "int32", + "nullable": true } } } @@ -17053,9 +18709,9 @@ } } }, - "/test_response_boolean_nullable": { + "/test_response_integer_int64": { "post": { - "operationId": "test_response_boolean_nullable", + "operationId": "test_response_integer_int64", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17065,7 +18721,80 @@ "content": { "application/json": { "schema": { - "type": "boolean", + "type": "integer", + "format": "int64" + } + } + } + } + } + } + }, + "/test_response_integer_int64_array": { + "post": { + "operationId": "test_response_integer_int64_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + } + } + } + } + } + } + }, + "/test_response_integer_int64_array_array": { + "post": { + "operationId": "test_response_integer_int64_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "int64" + } + } + } + } + } + } + } + } + }, + "/test_response_integer_int64_nullable": { + "post": { + "operationId": "test_response_integer_int64_nullable", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "int64", "nullable": true } } @@ -17074,9 +18803,9 @@ } } }, - "/test_response_boolean_nullable_array": { + "/test_response_integer_int64_nullable_array": { "post": { - "operationId": "test_response_boolean_nullable_array", + "operationId": "test_response_integer_int64_nullable_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17088,7 +18817,8 @@ "schema": { "type": "array", "items": { - "type": "boolean", + "type": "integer", + "format": "int64", "nullable": true } } @@ -17098,9 +18828,9 @@ } } }, - "/test_response_boolean_nullable_array_array": { + "/test_response_integer_int64_nullable_array_array": { "post": { - "operationId": "test_response_boolean_nullable_array_array", + "operationId": "test_response_integer_int64_nullable_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17114,7 +18844,8 @@ "items": { "type": "array", "items": { - "type": "boolean", + "type": "integer", + "format": "int64", "nullable": true } } @@ -17125,9 +18856,9 @@ } } }, - "/test_response_integer": { + "/test_response_integer_nullable": { "post": { - "operationId": "test_response_integer", + "operationId": "test_response_integer_nullable", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17137,7 +18868,8 @@ "content": { "application/json": { "schema": { - "type": "integer" + "type": "integer", + "nullable": true } } } @@ -17145,9 +18877,9 @@ } } }, - "/test_response_integer_array": { + "/test_response_integer_nullable_array": { "post": { - "operationId": "test_response_integer_array", + "operationId": "test_response_integer_nullable_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17159,7 +18891,8 @@ "schema": { "type": "array", "items": { - "type": "integer" + "type": "integer", + "nullable": true } } } @@ -17168,9 +18901,9 @@ } } }, - "/test_response_integer_array_array": { + "/test_response_integer_nullable_array_array": { "post": { - "operationId": "test_response_integer_array_array", + "operationId": "test_response_integer_nullable_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17184,7 +18917,8 @@ "items": { "type": "array", "items": { - "type": "integer" + "type": "integer", + "nullable": true } } } @@ -17194,9 +18928,9 @@ } } }, - "/test_response_integer_int32": { + "/test_response_integer_uint": { "post": { - "operationId": "test_response_integer_int32", + "operationId": "test_response_integer_uint", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17207,7 +18941,7 @@ "application/json": { "schema": { "type": "integer", - "format": "int32" + "format": "uint" } } } @@ -17215,9 +18949,30 @@ } } }, - "/test_response_integer_int32_array": { + "/test_response_integer_uint32": { "post": { - "operationId": "test_response_integer_int32_array", + "operationId": "test_response_integer_uint32", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "integer", + "format": "uint32" + } + } + } + } + } + } + }, + "/test_response_integer_uint32_array": { + "post": { + "operationId": "test_response_integer_uint32_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17230,7 +18985,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32" + "format": "uint32" } } } @@ -17239,9 +18994,9 @@ } } }, - "/test_response_integer_int32_array_array": { + "/test_response_integer_uint32_array_array": { "post": { - "operationId": "test_response_integer_int32_array_array", + "operationId": "test_response_integer_uint32_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17256,7 +19011,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32" + "format": "uint32" } } } @@ -17266,9 +19021,9 @@ } } }, - "/test_response_integer_int32_nullable": { + "/test_response_integer_uint32_nullable": { "post": { - "operationId": "test_response_integer_int32_nullable", + "operationId": "test_response_integer_uint32_nullable", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17279,7 +19034,7 @@ "application/json": { "schema": { "type": "integer", - "format": "int32", + "format": "uint32", "nullable": true } } @@ -17288,9 +19043,9 @@ } } }, - "/test_response_integer_int32_nullable_array": { + "/test_response_integer_uint32_nullable_array": { "post": { - "operationId": "test_response_integer_int32_nullable_array", + "operationId": "test_response_integer_uint32_nullable_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17303,7 +19058,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32", + "format": "uint32", "nullable": true } } @@ -17313,9 +19068,9 @@ } } }, - "/test_response_integer_int32_nullable_array_array": { + "/test_response_integer_uint32_nullable_array_array": { "post": { - "operationId": "test_response_integer_int32_nullable_array_array", + "operationId": "test_response_integer_uint32_nullable_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17330,7 +19085,7 @@ "type": "array", "items": { "type": "integer", - "format": "int32", + "format": "uint32", "nullable": true } } @@ -17341,9 +19096,9 @@ } } }, - "/test_response_integer_int64": { + "/test_response_integer_uint64": { "post": { - "operationId": "test_response_integer_int64", + "operationId": "test_response_integer_uint64", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17354,7 +19109,7 @@ "application/json": { "schema": { "type": "integer", - "format": "int64" + "format": "uint64" } } } @@ -17362,9 +19117,9 @@ } } }, - "/test_response_integer_int64_array": { + "/test_response_integer_uint64_array": { "post": { - "operationId": "test_response_integer_int64_array", + "operationId": "test_response_integer_uint64_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17377,7 +19132,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64" + "format": "uint64" } } } @@ -17386,9 +19141,9 @@ } } }, - "/test_response_integer_int64_array_array": { + "/test_response_integer_uint64_array_array": { "post": { - "operationId": "test_response_integer_int64_array_array", + "operationId": "test_response_integer_uint64_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17403,7 +19158,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64" + "format": "uint64" } } } @@ -17413,9 +19168,9 @@ } } }, - "/test_response_integer_int64_nullable": { + "/test_response_integer_uint64_nullable": { "post": { - "operationId": "test_response_integer_int64_nullable", + "operationId": "test_response_integer_uint64_nullable", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17426,7 +19181,7 @@ "application/json": { "schema": { "type": "integer", - "format": "int64", + "format": "uint64", "nullable": true } } @@ -17435,9 +19190,9 @@ } } }, - "/test_response_integer_int64_nullable_array": { + "/test_response_integer_uint64_nullable_array": { "post": { - "operationId": "test_response_integer_int64_nullable_array", + "operationId": "test_response_integer_uint64_nullable_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17450,7 +19205,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64", + "format": "uint64", "nullable": true } } @@ -17460,9 +19215,9 @@ } } }, - "/test_response_integer_int64_nullable_array_array": { + "/test_response_integer_uint64_nullable_array_array": { "post": { - "operationId": "test_response_integer_int64_nullable_array_array", + "operationId": "test_response_integer_uint64_nullable_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17477,7 +19232,7 @@ "type": "array", "items": { "type": "integer", - "format": "int64", + "format": "uint64", "nullable": true } } @@ -17488,9 +19243,60 @@ } } }, - "/test_response_integer_nullable": { + "/test_response_integer_uint_array": { "post": { - "operationId": "test_response_integer_nullable", + "operationId": "test_response_integer_uint_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + } + } + } + } + } + }, + "/test_response_integer_uint_array_array": { + "post": { + "operationId": "test_response_integer_uint_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "integer", + "format": "uint" + } + } + } + } + } + } + } + } + }, + "/test_response_integer_uint_nullable": { + "post": { + "operationId": "test_response_integer_uint_nullable", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17501,6 +19307,7 @@ "application/json": { "schema": { "type": "integer", + "format": "uint", "nullable": true } } @@ -17509,9 +19316,9 @@ } } }, - "/test_response_integer_nullable_array": { + "/test_response_integer_uint_nullable_array": { "post": { - "operationId": "test_response_integer_nullable_array", + "operationId": "test_response_integer_uint_nullable_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17524,6 +19331,7 @@ "type": "array", "items": { "type": "integer", + "format": "uint", "nullable": true } } @@ -17533,9 +19341,9 @@ } } }, - "/test_response_integer_nullable_array_array": { + "/test_response_integer_uint_nullable_array_array": { "post": { - "operationId": "test_response_integer_nullable_array_array", + "operationId": "test_response_integer_uint_nullable_array_array", "requestBody": { "$ref": "#/components/requestBodies/defaultBody" }, @@ -17550,6 +19358,7 @@ "type": "array", "items": { "type": "integer", + "format": "uint", "nullable": true } } diff --git a/conv/decode.go b/conv/decode.go index 188cab5fc..dc705a893 100644 --- a/conv/decode.go +++ b/conv/decode.go @@ -10,8 +10,17 @@ import ( ) func ToInt(s string) (int, error) { - v, err := strconv.ParseInt(s, 10, 32) - return int(v), err + return strconv.Atoi(s) +} + +func ToInt8(s string) (int8, error) { + v, err := strconv.ParseInt(s, 10, 8) + return int8(v), err +} + +func ToInt16(s string) (int16, error) { + v, err := strconv.ParseInt(s, 10, 16) + return int16(v), err } func ToInt32(s string) (int32, error) { @@ -23,6 +32,30 @@ func ToInt64(s string) (int64, error) { return strconv.ParseInt(s, 10, 64) } +func ToUint(s string) (uint, error) { + v, err := strconv.ParseUint(s, 10, 0) + return uint(v), err +} + +func ToUint8(s string) (uint8, error) { + v, err := strconv.ParseUint(s, 10, 8) + return uint8(v), err +} + +func ToUint16(s string) (uint16, error) { + v, err := strconv.ParseUint(s, 10, 16) + return uint16(v), err +} + +func ToUint32(s string) (uint32, error) { + v, err := strconv.ParseUint(s, 10, 32) + return uint32(v), err +} + +func ToUint64(s string) (uint64, error) { + return strconv.ParseUint(s, 10, 64) +} + func ToFloat32(s string) (float32, error) { v, err := strconv.ParseFloat(s, 32) return float32(v), err diff --git a/conv/encode.go b/conv/encode.go index b59f06dfd..bde6c56b7 100644 --- a/conv/encode.go +++ b/conv/encode.go @@ -9,12 +9,18 @@ import ( "github.com/google/uuid" ) -func IntToString(v int) string { return strconv.Itoa(v) } - -func Int32ToString(v int32) string { return strconv.Itoa(int(v)) } - +func IntToString(v int) string { return strconv.Itoa(v) } +func Int8ToString(v int8) string { return strconv.FormatInt(int64(v), 10) } +func Int16ToString(v int16) string { return strconv.FormatInt(int64(v), 10) } +func Int32ToString(v int32) string { return strconv.FormatInt(int64(v), 10) } func Int64ToString(v int64) string { return strconv.FormatInt(v, 10) } +func UintToString(v uint) string { return strconv.FormatUint(uint64(v), 10) } +func Uint8ToString(v uint8) string { return strconv.FormatUint(uint64(v), 10) } +func Uint16ToString(v uint16) string { return strconv.FormatUint(uint64(v), 10) } +func Uint32ToString(v uint32) string { return strconv.FormatUint(uint64(v), 10) } +func Uint64ToString(v uint64) string { return strconv.FormatUint(v, 10) } + func Float32ToString(v float32) string { return strconv.FormatFloat(float64(v), 'f', 10, 64) } func Float64ToString(v float64) string { return strconv.FormatFloat(v, 'f', 10, 64) } diff --git a/examples/ex_test_format/oas_client_gen.go b/examples/ex_test_format/oas_client_gen.go index e9185055b..96d1cfbb7 100644 --- a/examples/ex_test_format/oas_client_gen.go +++ b/examples/ex_test_format/oas_client_gen.go @@ -244,6 +244,117 @@ func (c *Client) TestQueryParameter(ctx context.Context, request string, params return res, errors.Wrap(err, "encode query") } } + { + // Encode "integer_uint" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "integer_uint", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeValue(conv.UintToString(params.IntegerUint)) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "integer_uint32" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "integer_uint32", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeValue(conv.Uint32ToString(params.IntegerUint32)) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "integer_uint32_array" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "integer_uint32_array", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.IntegerUint32Array { + if err := func() error { + return e.EncodeValue(conv.Uint32ToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "integer_uint64" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "integer_uint64", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeValue(conv.Uint64ToString(params.IntegerUint64)) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "integer_uint64_array" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "integer_uint64_array", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.IntegerUint64Array { + if err := func() error { + return e.EncodeValue(conv.Uint64ToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "integer_uint_array" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "integer_uint_array", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.IntegerUintArray { + if err := func() error { + return e.EncodeValue(conv.UintToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } { // Encode "integer_unix" parameter. cfg := uri.QueryParameterEncodingConfig{ @@ -3374,164 +3485,14 @@ func (c *Client) TestRequestIntegerNullableArrayArray(ctx context.Context, reque return result, nil } -// TestRequestIntegerUnix invokes test_request_integer_unix operation. -// -// POST /test_request_integer_unix -func (c *Client) TestRequestIntegerUnix(ctx context.Context, request OptUnixSeconds) (res Error, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix"), - } - // Validate request before sending. - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - c.requests.Add(ctx, 1, otelAttrs...) - - // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnix", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), - ) - // Track stage for error reporting. - var stage string - defer func() { - if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - c.errors.Add(ctx, 1, otelAttrs...) - } - span.End() - }() - - stage = "BuildURL" - u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix" - - stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "POST", u, nil) - if err != nil { - return res, errors.Wrap(err, "create request") - } - if err := encodeTestRequestIntegerUnixRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") - } - - stage = "SendRequest" - resp, err := c.cfg.Client.Do(r) - if err != nil { - return res, errors.Wrap(err, "do request") - } - defer resp.Body.Close() - - stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixResponse(resp, span) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// TestRequestIntegerUnixArray invokes test_request_integer_unix_array operation. -// -// POST /test_request_integer_unix_array -func (c *Client) TestRequestIntegerUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_array"), - } - // Validate request before sending. - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - c.requests.Add(ctx, 1, otelAttrs...) - - // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), - ) - // Track stage for error reporting. - var stage string - defer func() { - if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - c.errors.Add(ctx, 1, otelAttrs...) - } - span.End() - }() - - stage = "BuildURL" - u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix_array" - - stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "POST", u, nil) - if err != nil { - return res, errors.Wrap(err, "create request") - } - if err := encodeTestRequestIntegerUnixArrayRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") - } - - stage = "SendRequest" - resp, err := c.cfg.Client.Do(r) - if err != nil { - return res, errors.Wrap(err, "do request") - } - defer resp.Body.Close() - - stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixArrayResponse(resp, span) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// TestRequestIntegerUnixArrayArray invokes test_request_integer_unix_array_array operation. +// TestRequestIntegerUint invokes test_request_integer_uint operation. // -// POST /test_request_integer_unix_array_array -func (c *Client) TestRequestIntegerUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_integer_uint +func (c *Client) TestRequestIntegerUint(ctx context.Context, request OptUint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_array_array"), + otelogen.OperationID("test_request_integer_uint"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -3544,7 +3505,7 @@ func (c *Client) TestRequestIntegerUnixArrayArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -3561,14 +3522,14 @@ func (c *Client) TestRequestIntegerUnixArrayArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix_array_array" + u.Path += "/test_request_integer_uint" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUintRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -3580,7 +3541,7 @@ func (c *Client) TestRequestIntegerUnixArrayArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUintResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -3588,12 +3549,12 @@ func (c *Client) TestRequestIntegerUnixArrayArray(ctx context.Context, request [ return result, nil } -// TestRequestIntegerUnixMicro invokes test_request_integer_unix-micro operation. +// TestRequestIntegerUint32 invokes test_request_integer_uint32 operation. // -// POST /test_request_integer_unix-micro -func (c *Client) TestRequestIntegerUnixMicro(ctx context.Context, request OptUnixMicro) (res Error, err error) { +// POST /test_request_integer_uint32 +func (c *Client) TestRequestIntegerUint32(ctx context.Context, request OptUint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro"), + otelogen.OperationID("test_request_integer_uint32"), } // Validate request before sending. @@ -3608,7 +3569,7 @@ func (c *Client) TestRequestIntegerUnixMicro(ctx context.Context, request OptUni c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicro", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -3625,14 +3586,14 @@ func (c *Client) TestRequestIntegerUnixMicro(ctx context.Context, request OptUni stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-micro" + u.Path += "/test_request_integer_uint32" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMicroRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint32Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -3644,7 +3605,7 @@ func (c *Client) TestRequestIntegerUnixMicro(ctx context.Context, request OptUni defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMicroResponse(resp, span) + result, err := decodeTestRequestIntegerUint32Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -3652,12 +3613,12 @@ func (c *Client) TestRequestIntegerUnixMicro(ctx context.Context, request OptUni return result, nil } -// TestRequestIntegerUnixMicroArray invokes test_request_integer_unix-micro_array operation. +// TestRequestIntegerUint32Array invokes test_request_integer_uint32_array operation. // -// POST /test_request_integer_unix-micro_array -func (c *Client) TestRequestIntegerUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_integer_uint32_array +func (c *Client) TestRequestIntegerUint32Array(ctx context.Context, request []uint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_array"), + otelogen.OperationID("test_request_integer_uint32_array"), } // Validate request before sending. @@ -3672,7 +3633,7 @@ func (c *Client) TestRequestIntegerUnixMicroArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -3689,14 +3650,14 @@ func (c *Client) TestRequestIntegerUnixMicroArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-micro_array" + u.Path += "/test_request_integer_uint32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMicroArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -3708,7 +3669,7 @@ func (c *Client) TestRequestIntegerUnixMicroArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMicroArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUint32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -3716,12 +3677,12 @@ func (c *Client) TestRequestIntegerUnixMicroArray(ctx context.Context, request [ return result, nil } -// TestRequestIntegerUnixMicroArrayArray invokes test_request_integer_unix-micro_array_array operation. +// TestRequestIntegerUint32ArrayArray invokes test_request_integer_uint32_array_array operation. // -// POST /test_request_integer_unix-micro_array_array -func (c *Client) TestRequestIntegerUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_integer_uint32_array_array +func (c *Client) TestRequestIntegerUint32ArrayArray(ctx context.Context, request [][]uint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_array_array"), + otelogen.OperationID("test_request_integer_uint32_array_array"), } // Validate request before sending. if err := func() error { @@ -3758,7 +3719,7 @@ func (c *Client) TestRequestIntegerUnixMicroArrayArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -3775,14 +3736,14 @@ func (c *Client) TestRequestIntegerUnixMicroArrayArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-micro_array_array" + u.Path += "/test_request_integer_uint32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMicroArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -3794,7 +3755,7 @@ func (c *Client) TestRequestIntegerUnixMicroArrayArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMicroArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUint32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -3802,12 +3763,12 @@ func (c *Client) TestRequestIntegerUnixMicroArrayArray(ctx context.Context, requ return result, nil } -// TestRequestIntegerUnixMicroNullable invokes test_request_integer_unix-micro_nullable operation. +// TestRequestIntegerUint32Nullable invokes test_request_integer_uint32_nullable operation. // -// POST /test_request_integer_unix-micro_nullable -func (c *Client) TestRequestIntegerUnixMicroNullable(ctx context.Context, request OptNilUnixMicro) (res Error, err error) { +// POST /test_request_integer_uint32_nullable +func (c *Client) TestRequestIntegerUint32Nullable(ctx context.Context, request OptNilUint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_nullable"), + otelogen.OperationID("test_request_integer_uint32_nullable"), } // Validate request before sending. @@ -3822,7 +3783,7 @@ func (c *Client) TestRequestIntegerUnixMicroNullable(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -3839,14 +3800,14 @@ func (c *Client) TestRequestIntegerUnixMicroNullable(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-micro_nullable" + u.Path += "/test_request_integer_uint32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMicroNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -3858,7 +3819,7 @@ func (c *Client) TestRequestIntegerUnixMicroNullable(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMicroNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUint32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -3866,12 +3827,12 @@ func (c *Client) TestRequestIntegerUnixMicroNullable(ctx context.Context, reques return result, nil } -// TestRequestIntegerUnixMicroNullableArray invokes test_request_integer_unix-micro_nullable_array operation. +// TestRequestIntegerUint32NullableArray invokes test_request_integer_uint32_nullable_array operation. // -// POST /test_request_integer_unix-micro_nullable_array -func (c *Client) TestRequestIntegerUnixMicroNullableArray(ctx context.Context, request []NilUnixMicro) (res Error, err error) { +// POST /test_request_integer_uint32_nullable_array +func (c *Client) TestRequestIntegerUint32NullableArray(ctx context.Context, request []NilUint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_nullable_array"), + otelogen.OperationID("test_request_integer_uint32_nullable_array"), } // Validate request before sending. @@ -3886,7 +3847,7 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -3903,14 +3864,14 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-micro_nullable_array" + u.Path += "/test_request_integer_uint32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMicroNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -3922,7 +3883,7 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMicroNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUint32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -3930,12 +3891,12 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArray(ctx context.Context, r return result, nil } -// TestRequestIntegerUnixMicroNullableArrayArray invokes test_request_integer_unix-micro_nullable_array_array operation. +// TestRequestIntegerUint32NullableArrayArray invokes test_request_integer_uint32_nullable_array_array operation. // -// POST /test_request_integer_unix-micro_nullable_array_array -func (c *Client) TestRequestIntegerUnixMicroNullableArrayArray(ctx context.Context, request [][]NilUnixMicro) (res Error, err error) { +// POST /test_request_integer_uint32_nullable_array_array +func (c *Client) TestRequestIntegerUint32NullableArrayArray(ctx context.Context, request [][]NilUint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_integer_uint32_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -3972,7 +3933,7 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArrayArray(ctx context.Conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -3989,14 +3950,14 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArrayArray(ctx context.Conte stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-micro_nullable_array_array" + u.Path += "/test_request_integer_uint32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4008,7 +3969,7 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArrayArray(ctx context.Conte defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUint32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4016,12 +3977,12 @@ func (c *Client) TestRequestIntegerUnixMicroNullableArrayArray(ctx context.Conte return result, nil } -// TestRequestIntegerUnixMilli invokes test_request_integer_unix-milli operation. +// TestRequestIntegerUint64 invokes test_request_integer_uint64 operation. // -// POST /test_request_integer_unix-milli -func (c *Client) TestRequestIntegerUnixMilli(ctx context.Context, request OptUnixMilli) (res Error, err error) { +// POST /test_request_integer_uint64 +func (c *Client) TestRequestIntegerUint64(ctx context.Context, request OptUint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli"), + otelogen.OperationID("test_request_integer_uint64"), } // Validate request before sending. @@ -4036,7 +3997,7 @@ func (c *Client) TestRequestIntegerUnixMilli(ctx context.Context, request OptUni c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilli", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4053,14 +4014,14 @@ func (c *Client) TestRequestIntegerUnixMilli(ctx context.Context, request OptUni stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-milli" + u.Path += "/test_request_integer_uint64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMilliRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4072,7 +4033,7 @@ func (c *Client) TestRequestIntegerUnixMilli(ctx context.Context, request OptUni defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMilliResponse(resp, span) + result, err := decodeTestRequestIntegerUint64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4080,12 +4041,12 @@ func (c *Client) TestRequestIntegerUnixMilli(ctx context.Context, request OptUni return result, nil } -// TestRequestIntegerUnixMilliArray invokes test_request_integer_unix-milli_array operation. +// TestRequestIntegerUint64Array invokes test_request_integer_uint64_array operation. // -// POST /test_request_integer_unix-milli_array -func (c *Client) TestRequestIntegerUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_integer_uint64_array +func (c *Client) TestRequestIntegerUint64Array(ctx context.Context, request []uint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_array"), + otelogen.OperationID("test_request_integer_uint64_array"), } // Validate request before sending. @@ -4100,7 +4061,7 @@ func (c *Client) TestRequestIntegerUnixMilliArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4117,14 +4078,14 @@ func (c *Client) TestRequestIntegerUnixMilliArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-milli_array" + u.Path += "/test_request_integer_uint64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMilliArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4136,7 +4097,7 @@ func (c *Client) TestRequestIntegerUnixMilliArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMilliArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUint64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4144,12 +4105,12 @@ func (c *Client) TestRequestIntegerUnixMilliArray(ctx context.Context, request [ return result, nil } -// TestRequestIntegerUnixMilliArrayArray invokes test_request_integer_unix-milli_array_array operation. +// TestRequestIntegerUint64ArrayArray invokes test_request_integer_uint64_array_array operation. // -// POST /test_request_integer_unix-milli_array_array -func (c *Client) TestRequestIntegerUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_integer_uint64_array_array +func (c *Client) TestRequestIntegerUint64ArrayArray(ctx context.Context, request [][]uint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_array_array"), + otelogen.OperationID("test_request_integer_uint64_array_array"), } // Validate request before sending. if err := func() error { @@ -4186,7 +4147,7 @@ func (c *Client) TestRequestIntegerUnixMilliArrayArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4203,14 +4164,14 @@ func (c *Client) TestRequestIntegerUnixMilliArrayArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-milli_array_array" + u.Path += "/test_request_integer_uint64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMilliArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4222,7 +4183,7 @@ func (c *Client) TestRequestIntegerUnixMilliArrayArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMilliArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUint64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4230,12 +4191,12 @@ func (c *Client) TestRequestIntegerUnixMilliArrayArray(ctx context.Context, requ return result, nil } -// TestRequestIntegerUnixMilliNullable invokes test_request_integer_unix-milli_nullable operation. +// TestRequestIntegerUint64Nullable invokes test_request_integer_uint64_nullable operation. // -// POST /test_request_integer_unix-milli_nullable -func (c *Client) TestRequestIntegerUnixMilliNullable(ctx context.Context, request OptNilUnixMilli) (res Error, err error) { +// POST /test_request_integer_uint64_nullable +func (c *Client) TestRequestIntegerUint64Nullable(ctx context.Context, request OptNilUint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_nullable"), + otelogen.OperationID("test_request_integer_uint64_nullable"), } // Validate request before sending. @@ -4250,7 +4211,7 @@ func (c *Client) TestRequestIntegerUnixMilliNullable(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4267,14 +4228,14 @@ func (c *Client) TestRequestIntegerUnixMilliNullable(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-milli_nullable" + u.Path += "/test_request_integer_uint64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMilliNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4286,7 +4247,7 @@ func (c *Client) TestRequestIntegerUnixMilliNullable(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMilliNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUint64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4294,12 +4255,12 @@ func (c *Client) TestRequestIntegerUnixMilliNullable(ctx context.Context, reques return result, nil } -// TestRequestIntegerUnixMilliNullableArray invokes test_request_integer_unix-milli_nullable_array operation. +// TestRequestIntegerUint64NullableArray invokes test_request_integer_uint64_nullable_array operation. // -// POST /test_request_integer_unix-milli_nullable_array -func (c *Client) TestRequestIntegerUnixMilliNullableArray(ctx context.Context, request []NilUnixMilli) (res Error, err error) { +// POST /test_request_integer_uint64_nullable_array +func (c *Client) TestRequestIntegerUint64NullableArray(ctx context.Context, request []NilUint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_nullable_array"), + otelogen.OperationID("test_request_integer_uint64_nullable_array"), } // Validate request before sending. @@ -4314,7 +4275,7 @@ func (c *Client) TestRequestIntegerUnixMilliNullableArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4331,14 +4292,14 @@ func (c *Client) TestRequestIntegerUnixMilliNullableArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-milli_nullable_array" + u.Path += "/test_request_integer_uint64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixMilliNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4350,7 +4311,7 @@ func (c *Client) TestRequestIntegerUnixMilliNullableArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMilliNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUint64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4358,12 +4319,12 @@ func (c *Client) TestRequestIntegerUnixMilliNullableArray(ctx context.Context, r return result, nil } -// TestRequestIntegerUnixMilliNullableArrayArray invokes test_request_integer_unix-milli_nullable_array_array operation. +// TestRequestIntegerUint64NullableArrayArray invokes test_request_integer_uint64_nullable_array_array operation. // -// POST /test_request_integer_unix-milli_nullable_array_array -func (c *Client) TestRequestIntegerUnixMilliNullableArrayArray(ctx context.Context, request [][]NilUnixMilli) (res Error, err error) { +// POST /test_request_integer_uint64_nullable_array_array +func (c *Client) TestRequestIntegerUint64NullableArrayArray(ctx context.Context, request [][]NilUint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_integer_uint64_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -4400,71 +4361,7 @@ func (c *Client) TestRequestIntegerUnixMilliNullableArrayArray(ctx context.Conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliNullableArrayArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), - ) - // Track stage for error reporting. - var stage string - defer func() { - if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - c.errors.Add(ctx, 1, otelAttrs...) - } - span.End() - }() - - stage = "BuildURL" - u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-milli_nullable_array_array" - - stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "POST", u, nil) - if err != nil { - return res, errors.Wrap(err, "create request") - } - if err := encodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") - } - - stage = "SendRequest" - resp, err := c.cfg.Client.Do(r) - if err != nil { - return res, errors.Wrap(err, "do request") - } - defer resp.Body.Close() - - stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(resp, span) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// TestRequestIntegerUnixNano invokes test_request_integer_unix-nano operation. -// -// POST /test_request_integer_unix-nano -func (c *Client) TestRequestIntegerUnixNano(ctx context.Context, request OptUnixNano) (res Error, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano"), - } - // Validate request before sending. - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - c.requests.Add(ctx, 1, otelAttrs...) - - // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNano", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4481,14 +4378,14 @@ func (c *Client) TestRequestIntegerUnixNano(ctx context.Context, request OptUnix stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-nano" + u.Path += "/test_request_integer_uint64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNanoRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUint64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4500,7 +4397,7 @@ func (c *Client) TestRequestIntegerUnixNano(ctx context.Context, request OptUnix defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNanoResponse(resp, span) + result, err := decodeTestRequestIntegerUint64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4508,12 +4405,12 @@ func (c *Client) TestRequestIntegerUnixNano(ctx context.Context, request OptUnix return result, nil } -// TestRequestIntegerUnixNanoArray invokes test_request_integer_unix-nano_array operation. +// TestRequestIntegerUintArray invokes test_request_integer_uint_array operation. // -// POST /test_request_integer_unix-nano_array -func (c *Client) TestRequestIntegerUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_integer_uint_array +func (c *Client) TestRequestIntegerUintArray(ctx context.Context, request []uint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_array"), + otelogen.OperationID("test_request_integer_uint_array"), } // Validate request before sending. @@ -4528,7 +4425,7 @@ func (c *Client) TestRequestIntegerUnixNanoArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUintArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4545,14 +4442,14 @@ func (c *Client) TestRequestIntegerUnixNanoArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-nano_array" + u.Path += "/test_request_integer_uint_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNanoArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUintArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4564,7 +4461,7 @@ func (c *Client) TestRequestIntegerUnixNanoArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNanoArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUintArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4572,12 +4469,12 @@ func (c *Client) TestRequestIntegerUnixNanoArray(ctx context.Context, request [] return result, nil } -// TestRequestIntegerUnixNanoArrayArray invokes test_request_integer_unix-nano_array_array operation. +// TestRequestIntegerUintArrayArray invokes test_request_integer_uint_array_array operation. // -// POST /test_request_integer_unix-nano_array_array -func (c *Client) TestRequestIntegerUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_integer_uint_array_array +func (c *Client) TestRequestIntegerUintArrayArray(ctx context.Context, request [][]uint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_array_array"), + otelogen.OperationID("test_request_integer_uint_array_array"), } // Validate request before sending. if err := func() error { @@ -4614,7 +4511,7 @@ func (c *Client) TestRequestIntegerUnixNanoArrayArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUintArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4631,14 +4528,14 @@ func (c *Client) TestRequestIntegerUnixNanoArrayArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-nano_array_array" + u.Path += "/test_request_integer_uint_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNanoArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUintArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4650,7 +4547,7 @@ func (c *Client) TestRequestIntegerUnixNanoArrayArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNanoArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUintArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4658,12 +4555,12 @@ func (c *Client) TestRequestIntegerUnixNanoArrayArray(ctx context.Context, reque return result, nil } -// TestRequestIntegerUnixNanoNullable invokes test_request_integer_unix-nano_nullable operation. +// TestRequestIntegerUintNullable invokes test_request_integer_uint_nullable operation. // -// POST /test_request_integer_unix-nano_nullable -func (c *Client) TestRequestIntegerUnixNanoNullable(ctx context.Context, request OptNilUnixNano) (res Error, err error) { +// POST /test_request_integer_uint_nullable +func (c *Client) TestRequestIntegerUintNullable(ctx context.Context, request OptNilUint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_nullable"), + otelogen.OperationID("test_request_integer_uint_nullable"), } // Validate request before sending. @@ -4678,7 +4575,7 @@ func (c *Client) TestRequestIntegerUnixNanoNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUintNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4695,14 +4592,14 @@ func (c *Client) TestRequestIntegerUnixNanoNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-nano_nullable" + u.Path += "/test_request_integer_uint_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNanoNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUintNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4714,7 +4611,7 @@ func (c *Client) TestRequestIntegerUnixNanoNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNanoNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUintNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4722,12 +4619,12 @@ func (c *Client) TestRequestIntegerUnixNanoNullable(ctx context.Context, request return result, nil } -// TestRequestIntegerUnixNanoNullableArray invokes test_request_integer_unix-nano_nullable_array operation. +// TestRequestIntegerUintNullableArray invokes test_request_integer_uint_nullable_array operation. // -// POST /test_request_integer_unix-nano_nullable_array -func (c *Client) TestRequestIntegerUnixNanoNullableArray(ctx context.Context, request []NilUnixNano) (res Error, err error) { +// POST /test_request_integer_uint_nullable_array +func (c *Client) TestRequestIntegerUintNullableArray(ctx context.Context, request []NilUint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_nullable_array"), + otelogen.OperationID("test_request_integer_uint_nullable_array"), } // Validate request before sending. @@ -4742,7 +4639,7 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUintNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4759,14 +4656,14 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-nano_nullable_array" + u.Path += "/test_request_integer_uint_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNanoNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUintNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4778,7 +4675,7 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNanoNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUintNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4786,12 +4683,12 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArray(ctx context.Context, re return result, nil } -// TestRequestIntegerUnixNanoNullableArrayArray invokes test_request_integer_unix-nano_nullable_array_array operation. +// TestRequestIntegerUintNullableArrayArray invokes test_request_integer_uint_nullable_array_array operation. // -// POST /test_request_integer_unix-nano_nullable_array_array -func (c *Client) TestRequestIntegerUnixNanoNullableArrayArray(ctx context.Context, request [][]NilUnixNano) (res Error, err error) { +// POST /test_request_integer_uint_nullable_array_array +func (c *Client) TestRequestIntegerUintNullableArrayArray(ctx context.Context, request [][]NilUint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_integer_uint_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -4828,7 +4725,7 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUintNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4845,14 +4742,14 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-nano_nullable_array_array" + u.Path += "/test_request_integer_uint_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUintNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4864,7 +4761,7 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUintNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4872,12 +4769,12 @@ func (c *Client) TestRequestIntegerUnixNanoNullableArrayArray(ctx context.Contex return result, nil } -// TestRequestIntegerUnixNullable invokes test_request_integer_unix_nullable operation. +// TestRequestIntegerUnix invokes test_request_integer_unix operation. // -// POST /test_request_integer_unix_nullable -func (c *Client) TestRequestIntegerUnixNullable(ctx context.Context, request OptNilUnixSeconds) (res Error, err error) { +// POST /test_request_integer_unix +func (c *Client) TestRequestIntegerUnix(ctx context.Context, request OptUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_nullable"), + otelogen.OperationID("test_request_integer_unix"), } // Validate request before sending. @@ -4892,7 +4789,7 @@ func (c *Client) TestRequestIntegerUnixNullable(ctx context.Context, request Opt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnix", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4909,14 +4806,14 @@ func (c *Client) TestRequestIntegerUnixNullable(ctx context.Context, request Opt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix_nullable" + u.Path += "/test_request_integer_unix" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4928,7 +4825,7 @@ func (c *Client) TestRequestIntegerUnixNullable(ctx context.Context, request Opt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUnixResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -4936,12 +4833,12 @@ func (c *Client) TestRequestIntegerUnixNullable(ctx context.Context, request Opt return result, nil } -// TestRequestIntegerUnixNullableArray invokes test_request_integer_unix_nullable_array operation. +// TestRequestIntegerUnixArray invokes test_request_integer_unix_array operation. // -// POST /test_request_integer_unix_nullable_array -func (c *Client) TestRequestIntegerUnixNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { +// POST /test_request_integer_unix_array +func (c *Client) TestRequestIntegerUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_nullable_array"), + otelogen.OperationID("test_request_integer_unix_array"), } // Validate request before sending. @@ -4956,7 +4853,7 @@ func (c *Client) TestRequestIntegerUnixNullableArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -4973,14 +4870,14 @@ func (c *Client) TestRequestIntegerUnixNullableArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix_nullable_array" + u.Path += "/test_request_integer_unix_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -4992,7 +4889,7 @@ func (c *Client) TestRequestIntegerUnixNullableArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5000,12 +4897,12 @@ func (c *Client) TestRequestIntegerUnixNullableArray(ctx context.Context, reques return result, nil } -// TestRequestIntegerUnixNullableArrayArray invokes test_request_integer_unix_nullable_array_array operation. +// TestRequestIntegerUnixArrayArray invokes test_request_integer_unix_array_array operation. // -// POST /test_request_integer_unix_nullable_array_array -func (c *Client) TestRequestIntegerUnixNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { +// POST /test_request_integer_unix_array_array +func (c *Client) TestRequestIntegerUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix_array_array"), } // Validate request before sending. if err := func() error { @@ -5042,7 +4939,7 @@ func (c *Client) TestRequestIntegerUnixNullableArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5059,14 +4956,14 @@ func (c *Client) TestRequestIntegerUnixNullableArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix_nullable_array_array" + u.Path += "/test_request_integer_unix_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5078,7 +4975,7 @@ func (c *Client) TestRequestIntegerUnixNullableArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5086,12 +4983,12 @@ func (c *Client) TestRequestIntegerUnixNullableArrayArray(ctx context.Context, r return result, nil } -// TestRequestIntegerUnixSeconds invokes test_request_integer_unix-seconds operation. +// TestRequestIntegerUnixMicro invokes test_request_integer_unix-micro operation. // -// POST /test_request_integer_unix-seconds -func (c *Client) TestRequestIntegerUnixSeconds(ctx context.Context, request OptUnixSeconds) (res Error, err error) { +// POST /test_request_integer_unix-micro +func (c *Client) TestRequestIntegerUnixMicro(ctx context.Context, request OptUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds"), + otelogen.OperationID("test_request_integer_unix-micro"), } // Validate request before sending. @@ -5106,7 +5003,7 @@ func (c *Client) TestRequestIntegerUnixSeconds(ctx context.Context, request OptU c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSeconds", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicro", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5123,14 +5020,14 @@ func (c *Client) TestRequestIntegerUnixSeconds(ctx context.Context, request OptU stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-seconds" + u.Path += "/test_request_integer_unix-micro" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixSecondsRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMicroRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5142,7 +5039,7 @@ func (c *Client) TestRequestIntegerUnixSeconds(ctx context.Context, request OptU defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixSecondsResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMicroResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5150,12 +5047,12 @@ func (c *Client) TestRequestIntegerUnixSeconds(ctx context.Context, request OptU return result, nil } -// TestRequestIntegerUnixSecondsArray invokes test_request_integer_unix-seconds_array operation. +// TestRequestIntegerUnixMicroArray invokes test_request_integer_unix-micro_array operation. // -// POST /test_request_integer_unix-seconds_array -func (c *Client) TestRequestIntegerUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_integer_unix-micro_array +func (c *Client) TestRequestIntegerUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_array"), + otelogen.OperationID("test_request_integer_unix-micro_array"), } // Validate request before sending. @@ -5170,7 +5067,7 @@ func (c *Client) TestRequestIntegerUnixSecondsArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5187,14 +5084,14 @@ func (c *Client) TestRequestIntegerUnixSecondsArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-seconds_array" + u.Path += "/test_request_integer_unix-micro_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixSecondsArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMicroArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5206,7 +5103,7 @@ func (c *Client) TestRequestIntegerUnixSecondsArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixSecondsArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMicroArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5214,12 +5111,12 @@ func (c *Client) TestRequestIntegerUnixSecondsArray(ctx context.Context, request return result, nil } -// TestRequestIntegerUnixSecondsArrayArray invokes test_request_integer_unix-seconds_array_array operation. +// TestRequestIntegerUnixMicroArrayArray invokes test_request_integer_unix-micro_array_array operation. // -// POST /test_request_integer_unix-seconds_array_array -func (c *Client) TestRequestIntegerUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_integer_unix-micro_array_array +func (c *Client) TestRequestIntegerUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_array_array"), + otelogen.OperationID("test_request_integer_unix-micro_array_array"), } // Validate request before sending. if err := func() error { @@ -5256,7 +5153,7 @@ func (c *Client) TestRequestIntegerUnixSecondsArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5273,14 +5170,14 @@ func (c *Client) TestRequestIntegerUnixSecondsArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-seconds_array_array" + u.Path += "/test_request_integer_unix-micro_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixSecondsArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMicroArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5292,7 +5189,7 @@ func (c *Client) TestRequestIntegerUnixSecondsArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixSecondsArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMicroArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5300,12 +5197,12 @@ func (c *Client) TestRequestIntegerUnixSecondsArrayArray(ctx context.Context, re return result, nil } -// TestRequestIntegerUnixSecondsNullable invokes test_request_integer_unix-seconds_nullable operation. +// TestRequestIntegerUnixMicroNullable invokes test_request_integer_unix-micro_nullable operation. // -// POST /test_request_integer_unix-seconds_nullable -func (c *Client) TestRequestIntegerUnixSecondsNullable(ctx context.Context, request OptNilUnixSeconds) (res Error, err error) { +// POST /test_request_integer_unix-micro_nullable +func (c *Client) TestRequestIntegerUnixMicroNullable(ctx context.Context, request OptNilUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_nullable"), + otelogen.OperationID("test_request_integer_unix-micro_nullable"), } // Validate request before sending. @@ -5320,7 +5217,7 @@ func (c *Client) TestRequestIntegerUnixSecondsNullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5337,14 +5234,14 @@ func (c *Client) TestRequestIntegerUnixSecondsNullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-seconds_nullable" + u.Path += "/test_request_integer_unix-micro_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixSecondsNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMicroNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5356,7 +5253,7 @@ func (c *Client) TestRequestIntegerUnixSecondsNullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixSecondsNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMicroNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5364,12 +5261,12 @@ func (c *Client) TestRequestIntegerUnixSecondsNullable(ctx context.Context, requ return result, nil } -// TestRequestIntegerUnixSecondsNullableArray invokes test_request_integer_unix-seconds_nullable_array operation. +// TestRequestIntegerUnixMicroNullableArray invokes test_request_integer_unix-micro_nullable_array operation. // -// POST /test_request_integer_unix-seconds_nullable_array -func (c *Client) TestRequestIntegerUnixSecondsNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { +// POST /test_request_integer_unix-micro_nullable_array +func (c *Client) TestRequestIntegerUnixMicroNullableArray(ctx context.Context, request []NilUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_integer_unix-micro_nullable_array"), } // Validate request before sending. @@ -5384,7 +5281,7 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5401,14 +5298,14 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-seconds_nullable_array" + u.Path += "/test_request_integer_unix-micro_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixSecondsNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMicroNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5420,7 +5317,7 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixSecondsNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMicroNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5428,12 +5325,12 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArray(ctx context.Context, return result, nil } -// TestRequestIntegerUnixSecondsNullableArrayArray invokes test_request_integer_unix-seconds_nullable_array_array operation. +// TestRequestIntegerUnixMicroNullableArrayArray invokes test_request_integer_unix-micro_nullable_array_array operation. // -// POST /test_request_integer_unix-seconds_nullable_array_array -func (c *Client) TestRequestIntegerUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { +// POST /test_request_integer_unix-micro_nullable_array_array +func (c *Client) TestRequestIntegerUnixMicroNullableArrayArray(ctx context.Context, request [][]NilUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix-micro_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -5470,7 +5367,7 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5487,14 +5384,14 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_integer_unix-seconds_nullable_array_array" + u.Path += "/test_request_integer_unix-micro_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5506,7 +5403,7 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5514,12 +5411,12 @@ func (c *Client) TestRequestIntegerUnixSecondsNullableArrayArray(ctx context.Con return result, nil } -// TestRequestNull invokes test_request_null operation. +// TestRequestIntegerUnixMilli invokes test_request_integer_unix-milli operation. // -// POST /test_request_null -func (c *Client) TestRequestNull(ctx context.Context, request OptNull) (res Error, err error) { +// POST /test_request_integer_unix-milli +func (c *Client) TestRequestIntegerUnixMilli(ctx context.Context, request OptUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null"), + otelogen.OperationID("test_request_integer_unix-milli"), } // Validate request before sending. @@ -5534,7 +5431,7 @@ func (c *Client) TestRequestNull(ctx context.Context, request OptNull) (res Erro c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNull", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilli", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5551,14 +5448,14 @@ func (c *Client) TestRequestNull(ctx context.Context, request OptNull) (res Erro stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_null" + u.Path += "/test_request_integer_unix-milli" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNullRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMilliRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5570,7 +5467,7 @@ func (c *Client) TestRequestNull(ctx context.Context, request OptNull) (res Erro defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNullResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMilliResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5578,12 +5475,12 @@ func (c *Client) TestRequestNull(ctx context.Context, request OptNull) (res Erro return result, nil } -// TestRequestNullArray invokes test_request_null_array operation. +// TestRequestIntegerUnixMilliArray invokes test_request_integer_unix-milli_array operation. // -// POST /test_request_null_array -func (c *Client) TestRequestNullArray(ctx context.Context, request []struct{}) (res Error, err error) { +// POST /test_request_integer_unix-milli_array +func (c *Client) TestRequestIntegerUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_array"), + otelogen.OperationID("test_request_integer_unix-milli_array"), } // Validate request before sending. @@ -5598,7 +5495,7 @@ func (c *Client) TestRequestNullArray(ctx context.Context, request []struct{}) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5615,14 +5512,14 @@ func (c *Client) TestRequestNullArray(ctx context.Context, request []struct{}) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_null_array" + u.Path += "/test_request_integer_unix-milli_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNullArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMilliArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5634,7 +5531,7 @@ func (c *Client) TestRequestNullArray(ctx context.Context, request []struct{}) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNullArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMilliArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5642,12 +5539,12 @@ func (c *Client) TestRequestNullArray(ctx context.Context, request []struct{}) ( return result, nil } -// TestRequestNullArrayArray invokes test_request_null_array_array operation. +// TestRequestIntegerUnixMilliArrayArray invokes test_request_integer_unix-milli_array_array operation. // -// POST /test_request_null_array_array -func (c *Client) TestRequestNullArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { +// POST /test_request_integer_unix-milli_array_array +func (c *Client) TestRequestIntegerUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_array_array"), + otelogen.OperationID("test_request_integer_unix-milli_array_array"), } // Validate request before sending. if err := func() error { @@ -5684,7 +5581,7 @@ func (c *Client) TestRequestNullArrayArray(ctx context.Context, request [][]stru c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5701,14 +5598,14 @@ func (c *Client) TestRequestNullArrayArray(ctx context.Context, request [][]stru stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_null_array_array" + u.Path += "/test_request_integer_unix-milli_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNullArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMilliArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5720,7 +5617,7 @@ func (c *Client) TestRequestNullArrayArray(ctx context.Context, request [][]stru defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNullArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMilliArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5728,12 +5625,12 @@ func (c *Client) TestRequestNullArrayArray(ctx context.Context, request [][]stru return result, nil } -// TestRequestNullNullable invokes test_request_null_nullable operation. +// TestRequestIntegerUnixMilliNullable invokes test_request_integer_unix-milli_nullable operation. // -// POST /test_request_null_nullable -func (c *Client) TestRequestNullNullable(ctx context.Context, request OptNull) (res Error, err error) { +// POST /test_request_integer_unix-milli_nullable +func (c *Client) TestRequestIntegerUnixMilliNullable(ctx context.Context, request OptNilUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_nullable"), + otelogen.OperationID("test_request_integer_unix-milli_nullable"), } // Validate request before sending. @@ -5748,7 +5645,7 @@ func (c *Client) TestRequestNullNullable(ctx context.Context, request OptNull) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5765,14 +5662,14 @@ func (c *Client) TestRequestNullNullable(ctx context.Context, request OptNull) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_null_nullable" + u.Path += "/test_request_integer_unix-milli_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNullNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMilliNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5784,7 +5681,7 @@ func (c *Client) TestRequestNullNullable(ctx context.Context, request OptNull) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNullNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMilliNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5792,12 +5689,12 @@ func (c *Client) TestRequestNullNullable(ctx context.Context, request OptNull) ( return result, nil } -// TestRequestNullNullableArray invokes test_request_null_nullable_array operation. +// TestRequestIntegerUnixMilliNullableArray invokes test_request_integer_unix-milli_nullable_array operation. // -// POST /test_request_null_nullable_array -func (c *Client) TestRequestNullNullableArray(ctx context.Context, request []struct{}) (res Error, err error) { +// POST /test_request_integer_unix-milli_nullable_array +func (c *Client) TestRequestIntegerUnixMilliNullableArray(ctx context.Context, request []NilUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_nullable_array"), + otelogen.OperationID("test_request_integer_unix-milli_nullable_array"), } // Validate request before sending. @@ -5812,7 +5709,7 @@ func (c *Client) TestRequestNullNullableArray(ctx context.Context, request []str c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5829,14 +5726,14 @@ func (c *Client) TestRequestNullNullableArray(ctx context.Context, request []str stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_null_nullable_array" + u.Path += "/test_request_integer_unix-milli_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNullNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMilliNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5848,7 +5745,7 @@ func (c *Client) TestRequestNullNullableArray(ctx context.Context, request []str defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNullNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMilliNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5856,12 +5753,12 @@ func (c *Client) TestRequestNullNullableArray(ctx context.Context, request []str return result, nil } -// TestRequestNullNullableArrayArray invokes test_request_null_nullable_array_array operation. +// TestRequestIntegerUnixMilliNullableArrayArray invokes test_request_integer_unix-milli_nullable_array_array operation. // -// POST /test_request_null_nullable_array_array -func (c *Client) TestRequestNullNullableArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { +// POST /test_request_integer_unix-milli_nullable_array_array +func (c *Client) TestRequestIntegerUnixMilliNullableArrayArray(ctx context.Context, request [][]NilUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix-milli_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -5898,7 +5795,7 @@ func (c *Client) TestRequestNullNullableArrayArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5915,14 +5812,14 @@ func (c *Client) TestRequestNullNullableArrayArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_null_nullable_array_array" + u.Path += "/test_request_integer_unix-milli_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNullNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -5934,7 +5831,7 @@ func (c *Client) TestRequestNullNullableArrayArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNullNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -5942,29 +5839,14 @@ func (c *Client) TestRequestNullNullableArrayArray(ctx context.Context, request return result, nil } -// TestRequestNumber invokes test_request_number operation. +// TestRequestIntegerUnixNano invokes test_request_integer_unix-nano operation. // -// POST /test_request_number -func (c *Client) TestRequestNumber(ctx context.Context, request OptFloat64) (res Error, err error) { +// POST /test_request_integer_unix-nano +func (c *Client) TestRequestIntegerUnixNano(ctx context.Context, request OptUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number"), + otelogen.OperationID("test_request_integer_unix-nano"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -5977,7 +5859,7 @@ func (c *Client) TestRequestNumber(ctx context.Context, request OptFloat64) (res c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumber", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNano", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -5994,14 +5876,14 @@ func (c *Client) TestRequestNumber(ctx context.Context, request OptFloat64) (res stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number" + u.Path += "/test_request_integer_unix-nano" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNanoRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6013,7 +5895,7 @@ func (c *Client) TestRequestNumber(ctx context.Context, request OptFloat64) (res defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNanoResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6021,36 +5903,14 @@ func (c *Client) TestRequestNumber(ctx context.Context, request OptFloat64) (res return result, nil } -// TestRequestNumberArray invokes test_request_number_array operation. +// TestRequestIntegerUnixNanoArray invokes test_request_integer_unix-nano_array operation. // -// POST /test_request_number_array -func (c *Client) TestRequestNumberArray(ctx context.Context, request []float64) (res Error, err error) { +// POST /test_request_integer_unix-nano_array +func (c *Client) TestRequestIntegerUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_array"), + otelogen.OperationID("test_request_integer_unix-nano_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -6063,7 +5923,7 @@ func (c *Client) TestRequestNumberArray(ctx context.Context, request []float64) c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6080,14 +5940,14 @@ func (c *Client) TestRequestNumberArray(ctx context.Context, request []float64) stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_array" + u.Path += "/test_request_integer_unix-nano_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNanoArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6099,7 +5959,7 @@ func (c *Client) TestRequestNumberArray(ctx context.Context, request []float64) defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNanoArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6107,12 +5967,12 @@ func (c *Client) TestRequestNumberArray(ctx context.Context, request []float64) return result, nil } -// TestRequestNumberArrayArray invokes test_request_number_array_array operation. +// TestRequestIntegerUnixNanoArrayArray invokes test_request_integer_unix-nano_array_array operation. // -// POST /test_request_number_array_array -func (c *Client) TestRequestNumberArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { +// POST /test_request_integer_unix-nano_array_array +func (c *Client) TestRequestIntegerUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_array_array"), + otelogen.OperationID("test_request_integer_unix-nano_array_array"), } // Validate request before sending. if err := func() error { @@ -6122,23 +5982,6 @@ func (c *Client) TestRequestNumberArrayArray(ctx context.Context, request [][]fl if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6166,7 +6009,7 @@ func (c *Client) TestRequestNumberArrayArray(ctx context.Context, request [][]fl c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6183,14 +6026,14 @@ func (c *Client) TestRequestNumberArrayArray(ctx context.Context, request [][]fl stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_array_array" + u.Path += "/test_request_integer_unix-nano_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNanoArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6202,7 +6045,7 @@ func (c *Client) TestRequestNumberArrayArray(ctx context.Context, request [][]fl defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNanoArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6210,29 +6053,14 @@ func (c *Client) TestRequestNumberArrayArray(ctx context.Context, request [][]fl return result, nil } -// TestRequestNumberDouble invokes test_request_number_double operation. +// TestRequestIntegerUnixNanoNullable invokes test_request_integer_unix-nano_nullable operation. // -// POST /test_request_number_double -func (c *Client) TestRequestNumberDouble(ctx context.Context, request OptFloat64) (res Error, err error) { +// POST /test_request_integer_unix-nano_nullable +func (c *Client) TestRequestIntegerUnixNanoNullable(ctx context.Context, request OptNilUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double"), + otelogen.OperationID("test_request_integer_unix-nano_nullable"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -6245,7 +6073,7 @@ func (c *Client) TestRequestNumberDouble(ctx context.Context, request OptFloat64 c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDouble", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6262,14 +6090,14 @@ func (c *Client) TestRequestNumberDouble(ctx context.Context, request OptFloat64 stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_double" + u.Path += "/test_request_integer_unix-nano_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberDoubleRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNanoNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6281,7 +6109,7 @@ func (c *Client) TestRequestNumberDouble(ctx context.Context, request OptFloat64 defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberDoubleResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNanoNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6289,36 +6117,14 @@ func (c *Client) TestRequestNumberDouble(ctx context.Context, request OptFloat64 return result, nil } -// TestRequestNumberDoubleArray invokes test_request_number_double_array operation. +// TestRequestIntegerUnixNanoNullableArray invokes test_request_integer_unix-nano_nullable_array operation. // -// POST /test_request_number_double_array -func (c *Client) TestRequestNumberDoubleArray(ctx context.Context, request []float64) (res Error, err error) { +// POST /test_request_integer_unix-nano_nullable_array +func (c *Client) TestRequestIntegerUnixNanoNullableArray(ctx context.Context, request []NilUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_array"), + otelogen.OperationID("test_request_integer_unix-nano_nullable_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -6331,7 +6137,7 @@ func (c *Client) TestRequestNumberDoubleArray(ctx context.Context, request []flo c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6348,14 +6154,14 @@ func (c *Client) TestRequestNumberDoubleArray(ctx context.Context, request []flo stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_double_array" + u.Path += "/test_request_integer_unix-nano_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberDoubleArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNanoNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6367,7 +6173,7 @@ func (c *Client) TestRequestNumberDoubleArray(ctx context.Context, request []flo defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberDoubleArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNanoNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6375,12 +6181,12 @@ func (c *Client) TestRequestNumberDoubleArray(ctx context.Context, request []flo return result, nil } -// TestRequestNumberDoubleArrayArray invokes test_request_number_double_array_array operation. +// TestRequestIntegerUnixNanoNullableArrayArray invokes test_request_integer_unix-nano_nullable_array_array operation. // -// POST /test_request_number_double_array_array -func (c *Client) TestRequestNumberDoubleArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { +// POST /test_request_integer_unix-nano_nullable_array_array +func (c *Client) TestRequestIntegerUnixNanoNullableArrayArray(ctx context.Context, request [][]NilUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_array_array"), + otelogen.OperationID("test_request_integer_unix-nano_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -6390,23 +6196,6 @@ func (c *Client) TestRequestNumberDoubleArrayArray(ctx context.Context, request if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6434,7 +6223,7 @@ func (c *Client) TestRequestNumberDoubleArrayArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6451,14 +6240,14 @@ func (c *Client) TestRequestNumberDoubleArrayArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_double_array_array" + u.Path += "/test_request_integer_unix-nano_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberDoubleArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6470,7 +6259,7 @@ func (c *Client) TestRequestNumberDoubleArrayArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberDoubleArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6478,29 +6267,14 @@ func (c *Client) TestRequestNumberDoubleArrayArray(ctx context.Context, request return result, nil } -// TestRequestNumberDoubleNullable invokes test_request_number_double_nullable operation. +// TestRequestIntegerUnixNullable invokes test_request_integer_unix_nullable operation. // -// POST /test_request_number_double_nullable -func (c *Client) TestRequestNumberDoubleNullable(ctx context.Context, request OptNilFloat64) (res Error, err error) { +// POST /test_request_integer_unix_nullable +func (c *Client) TestRequestIntegerUnixNullable(ctx context.Context, request OptNilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_nullable"), + otelogen.OperationID("test_request_integer_unix_nullable"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -6513,7 +6287,7 @@ func (c *Client) TestRequestNumberDoubleNullable(ctx context.Context, request Op c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6530,14 +6304,14 @@ func (c *Client) TestRequestNumberDoubleNullable(ctx context.Context, request Op stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_double_nullable" + u.Path += "/test_request_integer_unix_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberDoubleNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6549,7 +6323,7 @@ func (c *Client) TestRequestNumberDoubleNullable(ctx context.Context, request Op defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberDoubleNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6557,36 +6331,14 @@ func (c *Client) TestRequestNumberDoubleNullable(ctx context.Context, request Op return result, nil } -// TestRequestNumberDoubleNullableArray invokes test_request_number_double_nullable_array operation. +// TestRequestIntegerUnixNullableArray invokes test_request_integer_unix_nullable_array operation. // -// POST /test_request_number_double_nullable_array -func (c *Client) TestRequestNumberDoubleNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { +// POST /test_request_integer_unix_nullable_array +func (c *Client) TestRequestIntegerUnixNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_nullable_array"), + otelogen.OperationID("test_request_integer_unix_nullable_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -6599,7 +6351,7 @@ func (c *Client) TestRequestNumberDoubleNullableArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6616,14 +6368,14 @@ func (c *Client) TestRequestNumberDoubleNullableArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_double_nullable_array" + u.Path += "/test_request_integer_unix_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberDoubleNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6635,7 +6387,7 @@ func (c *Client) TestRequestNumberDoubleNullableArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberDoubleNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6643,12 +6395,12 @@ func (c *Client) TestRequestNumberDoubleNullableArray(ctx context.Context, reque return result, nil } -// TestRequestNumberDoubleNullableArrayArray invokes test_request_number_double_nullable_array_array operation. +// TestRequestIntegerUnixNullableArrayArray invokes test_request_integer_unix_nullable_array_array operation. // -// POST /test_request_number_double_nullable_array_array -func (c *Client) TestRequestNumberDoubleNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { +// POST /test_request_integer_unix_nullable_array_array +func (c *Client) TestRequestIntegerUnixNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -6658,23 +6410,6 @@ func (c *Client) TestRequestNumberDoubleNullableArrayArray(ctx context.Context, if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6702,7 +6437,7 @@ func (c *Client) TestRequestNumberDoubleNullableArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6719,14 +6454,14 @@ func (c *Client) TestRequestNumberDoubleNullableArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_double_nullable_array_array" + u.Path += "/test_request_integer_unix_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberDoubleNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6738,7 +6473,7 @@ func (c *Client) TestRequestNumberDoubleNullableArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberDoubleNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6746,29 +6481,14 @@ func (c *Client) TestRequestNumberDoubleNullableArrayArray(ctx context.Context, return result, nil } -// TestRequestNumberFloat invokes test_request_number_float operation. +// TestRequestIntegerUnixSeconds invokes test_request_integer_unix-seconds operation. // -// POST /test_request_number_float -func (c *Client) TestRequestNumberFloat(ctx context.Context, request OptFloat32) (res Error, err error) { +// POST /test_request_integer_unix-seconds +func (c *Client) TestRequestIntegerUnixSeconds(ctx context.Context, request OptUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float"), + otelogen.OperationID("test_request_integer_unix-seconds"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -6781,7 +6501,7 @@ func (c *Client) TestRequestNumberFloat(ctx context.Context, request OptFloat32) c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloat", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSeconds", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6798,14 +6518,14 @@ func (c *Client) TestRequestNumberFloat(ctx context.Context, request OptFloat32) stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_float" + u.Path += "/test_request_integer_unix-seconds" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberFloatRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixSecondsRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6817,7 +6537,7 @@ func (c *Client) TestRequestNumberFloat(ctx context.Context, request OptFloat32) defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberFloatResponse(resp, span) + result, err := decodeTestRequestIntegerUnixSecondsResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6825,36 +6545,14 @@ func (c *Client) TestRequestNumberFloat(ctx context.Context, request OptFloat32) return result, nil } -// TestRequestNumberFloatArray invokes test_request_number_float_array operation. +// TestRequestIntegerUnixSecondsArray invokes test_request_integer_unix-seconds_array operation. // -// POST /test_request_number_float_array -func (c *Client) TestRequestNumberFloatArray(ctx context.Context, request []float32) (res Error, err error) { +// POST /test_request_integer_unix-seconds_array +func (c *Client) TestRequestIntegerUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_array"), + otelogen.OperationID("test_request_integer_unix-seconds_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -6867,7 +6565,7 @@ func (c *Client) TestRequestNumberFloatArray(ctx context.Context, request []floa c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6884,14 +6582,14 @@ func (c *Client) TestRequestNumberFloatArray(ctx context.Context, request []floa stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_float_array" + u.Path += "/test_request_integer_unix-seconds_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberFloatArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixSecondsArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -6903,7 +6601,7 @@ func (c *Client) TestRequestNumberFloatArray(ctx context.Context, request []floa defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberFloatArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixSecondsArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6911,12 +6609,12 @@ func (c *Client) TestRequestNumberFloatArray(ctx context.Context, request []floa return result, nil } -// TestRequestNumberFloatArrayArray invokes test_request_number_float_array_array operation. +// TestRequestIntegerUnixSecondsArrayArray invokes test_request_integer_unix-seconds_array_array operation. // -// POST /test_request_number_float_array_array -func (c *Client) TestRequestNumberFloatArrayArray(ctx context.Context, request [][]float32) (res Error, err error) { +// POST /test_request_integer_unix-seconds_array_array +func (c *Client) TestRequestIntegerUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_array_array"), + otelogen.OperationID("test_request_integer_unix-seconds_array_array"), } // Validate request before sending. if err := func() error { @@ -6926,23 +6624,6 @@ func (c *Client) TestRequestNumberFloatArrayArray(ctx context.Context, request [ if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6970,7 +6651,7 @@ func (c *Client) TestRequestNumberFloatArrayArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -6987,14 +6668,14 @@ func (c *Client) TestRequestNumberFloatArrayArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_float_array_array" + u.Path += "/test_request_integer_unix-seconds_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberFloatArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixSecondsArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7006,7 +6687,7 @@ func (c *Client) TestRequestNumberFloatArrayArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberFloatArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixSecondsArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7014,29 +6695,14 @@ func (c *Client) TestRequestNumberFloatArrayArray(ctx context.Context, request [ return result, nil } -// TestRequestNumberFloatNullable invokes test_request_number_float_nullable operation. +// TestRequestIntegerUnixSecondsNullable invokes test_request_integer_unix-seconds_nullable operation. // -// POST /test_request_number_float_nullable -func (c *Client) TestRequestNumberFloatNullable(ctx context.Context, request OptNilFloat32) (res Error, err error) { +// POST /test_request_integer_unix-seconds_nullable +func (c *Client) TestRequestIntegerUnixSecondsNullable(ctx context.Context, request OptNilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_nullable"), + otelogen.OperationID("test_request_integer_unix-seconds_nullable"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -7049,7 +6715,7 @@ func (c *Client) TestRequestNumberFloatNullable(ctx context.Context, request Opt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7066,14 +6732,14 @@ func (c *Client) TestRequestNumberFloatNullable(ctx context.Context, request Opt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_float_nullable" + u.Path += "/test_request_integer_unix-seconds_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberFloatNullableRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixSecondsNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7085,7 +6751,7 @@ func (c *Client) TestRequestNumberFloatNullable(ctx context.Context, request Opt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberFloatNullableResponse(resp, span) + result, err := decodeTestRequestIntegerUnixSecondsNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7093,36 +6759,14 @@ func (c *Client) TestRequestNumberFloatNullable(ctx context.Context, request Opt return result, nil } -// TestRequestNumberFloatNullableArray invokes test_request_number_float_nullable_array operation. +// TestRequestIntegerUnixSecondsNullableArray invokes test_request_integer_unix-seconds_nullable_array operation. // -// POST /test_request_number_float_nullable_array -func (c *Client) TestRequestNumberFloatNullableArray(ctx context.Context, request []NilFloat32) (res Error, err error) { +// POST /test_request_integer_unix-seconds_nullable_array +func (c *Client) TestRequestIntegerUnixSecondsNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_nullable_array"), + otelogen.OperationID("test_request_integer_unix-seconds_nullable_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -7135,7 +6779,7 @@ func (c *Client) TestRequestNumberFloatNullableArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7152,14 +6796,14 @@ func (c *Client) TestRequestNumberFloatNullableArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_float_nullable_array" + u.Path += "/test_request_integer_unix-seconds_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberFloatNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixSecondsNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7171,7 +6815,7 @@ func (c *Client) TestRequestNumberFloatNullableArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberFloatNullableArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixSecondsNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7179,12 +6823,12 @@ func (c *Client) TestRequestNumberFloatNullableArray(ctx context.Context, reques return result, nil } -// TestRequestNumberFloatNullableArrayArray invokes test_request_number_float_nullable_array_array operation. +// TestRequestIntegerUnixSecondsNullableArrayArray invokes test_request_integer_unix-seconds_nullable_array_array operation. // -// POST /test_request_number_float_nullable_array_array -func (c *Client) TestRequestNumberFloatNullableArrayArray(ctx context.Context, request [][]NilFloat32) (res Error, err error) { +// POST /test_request_integer_unix-seconds_nullable_array_array +func (c *Client) TestRequestIntegerUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix-seconds_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -7194,23 +6838,6 @@ func (c *Client) TestRequestNumberFloatNullableArrayArray(ctx context.Context, r if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -7238,7 +6865,7 @@ func (c *Client) TestRequestNumberFloatNullableArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestIntegerUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7255,14 +6882,14 @@ func (c *Client) TestRequestNumberFloatNullableArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_float_nullable_array_array" + u.Path += "/test_request_integer_unix-seconds_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberFloatNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7274,7 +6901,7 @@ func (c *Client) TestRequestNumberFloatNullableArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberFloatNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7282,12 +6909,12 @@ func (c *Client) TestRequestNumberFloatNullableArrayArray(ctx context.Context, r return result, nil } -// TestRequestNumberInt32 invokes test_request_number_int32 operation. +// TestRequestNull invokes test_request_null operation. // -// POST /test_request_number_int32 -func (c *Client) TestRequestNumberInt32(ctx context.Context, request OptInt32) (res Error, err error) { +// POST /test_request_null +func (c *Client) TestRequestNull(ctx context.Context, request OptNull) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32"), + otelogen.OperationID("test_request_null"), } // Validate request before sending. @@ -7302,7 +6929,7 @@ func (c *Client) TestRequestNumberInt32(ctx context.Context, request OptInt32) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNull", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7319,14 +6946,14 @@ func (c *Client) TestRequestNumberInt32(ctx context.Context, request OptInt32) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int32" + u.Path += "/test_request_null" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt32Request(request, r); err != nil { + if err := encodeTestRequestNullRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7338,7 +6965,7 @@ func (c *Client) TestRequestNumberInt32(ctx context.Context, request OptInt32) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt32Response(resp, span) + result, err := decodeTestRequestNullResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7346,12 +6973,12 @@ func (c *Client) TestRequestNumberInt32(ctx context.Context, request OptInt32) ( return result, nil } -// TestRequestNumberInt32Array invokes test_request_number_int32_array operation. +// TestRequestNullArray invokes test_request_null_array operation. // -// POST /test_request_number_int32_array -func (c *Client) TestRequestNumberInt32Array(ctx context.Context, request []int32) (res Error, err error) { +// POST /test_request_null_array +func (c *Client) TestRequestNullArray(ctx context.Context, request []struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_array"), + otelogen.OperationID("test_request_null_array"), } // Validate request before sending. @@ -7366,7 +6993,7 @@ func (c *Client) TestRequestNumberInt32Array(ctx context.Context, request []int3 c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7383,14 +7010,14 @@ func (c *Client) TestRequestNumberInt32Array(ctx context.Context, request []int3 stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int32_array" + u.Path += "/test_request_null_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt32ArrayRequest(request, r); err != nil { + if err := encodeTestRequestNullArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7402,7 +7029,7 @@ func (c *Client) TestRequestNumberInt32Array(ctx context.Context, request []int3 defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt32ArrayResponse(resp, span) + result, err := decodeTestRequestNullArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7410,12 +7037,12 @@ func (c *Client) TestRequestNumberInt32Array(ctx context.Context, request []int3 return result, nil } -// TestRequestNumberInt32ArrayArray invokes test_request_number_int32_array_array operation. +// TestRequestNullArrayArray invokes test_request_null_array_array operation. // -// POST /test_request_number_int32_array_array -func (c *Client) TestRequestNumberInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { +// POST /test_request_null_array_array +func (c *Client) TestRequestNullArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_array_array"), + otelogen.OperationID("test_request_null_array_array"), } // Validate request before sending. if err := func() error { @@ -7452,7 +7079,7 @@ func (c *Client) TestRequestNumberInt32ArrayArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7469,14 +7096,14 @@ func (c *Client) TestRequestNumberInt32ArrayArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int32_array_array" + u.Path += "/test_request_null_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt32ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNullArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7488,7 +7115,7 @@ func (c *Client) TestRequestNumberInt32ArrayArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt32ArrayArrayResponse(resp, span) + result, err := decodeTestRequestNullArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7496,12 +7123,12 @@ func (c *Client) TestRequestNumberInt32ArrayArray(ctx context.Context, request [ return result, nil } -// TestRequestNumberInt32Nullable invokes test_request_number_int32_nullable operation. +// TestRequestNullNullable invokes test_request_null_nullable operation. // -// POST /test_request_number_int32_nullable -func (c *Client) TestRequestNumberInt32Nullable(ctx context.Context, request OptNilInt32) (res Error, err error) { +// POST /test_request_null_nullable +func (c *Client) TestRequestNullNullable(ctx context.Context, request OptNull) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_nullable"), + otelogen.OperationID("test_request_null_nullable"), } // Validate request before sending. @@ -7516,7 +7143,7 @@ func (c *Client) TestRequestNumberInt32Nullable(ctx context.Context, request Opt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7533,14 +7160,14 @@ func (c *Client) TestRequestNumberInt32Nullable(ctx context.Context, request Opt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int32_nullable" + u.Path += "/test_request_null_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt32NullableRequest(request, r); err != nil { + if err := encodeTestRequestNullNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7552,7 +7179,7 @@ func (c *Client) TestRequestNumberInt32Nullable(ctx context.Context, request Opt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt32NullableResponse(resp, span) + result, err := decodeTestRequestNullNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7560,12 +7187,12 @@ func (c *Client) TestRequestNumberInt32Nullable(ctx context.Context, request Opt return result, nil } -// TestRequestNumberInt32NullableArray invokes test_request_number_int32_nullable_array operation. +// TestRequestNullNullableArray invokes test_request_null_nullable_array operation. // -// POST /test_request_number_int32_nullable_array -func (c *Client) TestRequestNumberInt32NullableArray(ctx context.Context, request []NilInt32) (res Error, err error) { +// POST /test_request_null_nullable_array +func (c *Client) TestRequestNullNullableArray(ctx context.Context, request []struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_nullable_array"), + otelogen.OperationID("test_request_null_nullable_array"), } // Validate request before sending. @@ -7580,7 +7207,7 @@ func (c *Client) TestRequestNumberInt32NullableArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7597,14 +7224,14 @@ func (c *Client) TestRequestNumberInt32NullableArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int32_nullable_array" + u.Path += "/test_request_null_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt32NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestNullNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7616,7 +7243,7 @@ func (c *Client) TestRequestNumberInt32NullableArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt32NullableArrayResponse(resp, span) + result, err := decodeTestRequestNullNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7624,12 +7251,12 @@ func (c *Client) TestRequestNumberInt32NullableArray(ctx context.Context, reques return result, nil } -// TestRequestNumberInt32NullableArrayArray invokes test_request_number_int32_nullable_array_array operation. +// TestRequestNullNullableArrayArray invokes test_request_null_nullable_array_array operation. // -// POST /test_request_number_int32_nullable_array_array -func (c *Client) TestRequestNumberInt32NullableArrayArray(ctx context.Context, request [][]NilInt32) (res Error, err error) { +// POST /test_request_null_nullable_array_array +func (c *Client) TestRequestNullNullableArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_nullable_array_array"), + otelogen.OperationID("test_request_null_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -7666,7 +7293,7 @@ func (c *Client) TestRequestNumberInt32NullableArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNullNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7683,14 +7310,14 @@ func (c *Client) TestRequestNumberInt32NullableArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int32_nullable_array_array" + u.Path += "/test_request_null_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt32NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNullNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7702,7 +7329,7 @@ func (c *Client) TestRequestNumberInt32NullableArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt32NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestNullNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7710,14 +7337,29 @@ func (c *Client) TestRequestNumberInt32NullableArrayArray(ctx context.Context, r return result, nil } -// TestRequestNumberInt64 invokes test_request_number_int64 operation. +// TestRequestNumber invokes test_request_number operation. // -// POST /test_request_number_int64 -func (c *Client) TestRequestNumberInt64(ctx context.Context, request OptInt64) (res Error, err error) { +// POST /test_request_number +func (c *Client) TestRequestNumber(ctx context.Context, request OptFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64"), + otelogen.OperationID("test_request_number"), } // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -7730,7 +7372,7 @@ func (c *Client) TestRequestNumberInt64(ctx context.Context, request OptInt64) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumber", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7747,14 +7389,14 @@ func (c *Client) TestRequestNumberInt64(ctx context.Context, request OptInt64) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int64" + u.Path += "/test_request_number" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt64Request(request, r); err != nil { + if err := encodeTestRequestNumberRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7766,7 +7408,7 @@ func (c *Client) TestRequestNumberInt64(ctx context.Context, request OptInt64) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt64Response(resp, span) + result, err := decodeTestRequestNumberResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7774,14 +7416,36 @@ func (c *Client) TestRequestNumberInt64(ctx context.Context, request OptInt64) ( return result, nil } -// TestRequestNumberInt64Array invokes test_request_number_int64_array operation. +// TestRequestNumberArray invokes test_request_number_array operation. // -// POST /test_request_number_int64_array -func (c *Client) TestRequestNumberInt64Array(ctx context.Context, request []int64) (res Error, err error) { +// POST /test_request_number_array +func (c *Client) TestRequestNumberArray(ctx context.Context, request []float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_array"), + otelogen.OperationID("test_request_number_array"), } // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -7794,7 +7458,7 @@ func (c *Client) TestRequestNumberInt64Array(ctx context.Context, request []int6 c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7811,14 +7475,14 @@ func (c *Client) TestRequestNumberInt64Array(ctx context.Context, request []int6 stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int64_array" + u.Path += "/test_request_number_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt64ArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7830,7 +7494,7 @@ func (c *Client) TestRequestNumberInt64Array(ctx context.Context, request []int6 defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt64ArrayResponse(resp, span) + result, err := decodeTestRequestNumberArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7838,12 +7502,12 @@ func (c *Client) TestRequestNumberInt64Array(ctx context.Context, request []int6 return result, nil } -// TestRequestNumberInt64ArrayArray invokes test_request_number_int64_array_array operation. +// TestRequestNumberArrayArray invokes test_request_number_array_array operation. // -// POST /test_request_number_int64_array_array -func (c *Client) TestRequestNumberInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { +// POST /test_request_number_array_array +func (c *Client) TestRequestNumberArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_array_array"), + otelogen.OperationID("test_request_number_array_array"), } // Validate request before sending. if err := func() error { @@ -7853,6 +7517,23 @@ func (c *Client) TestRequestNumberInt64ArrayArray(ctx context.Context, request [ if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -7880,7 +7561,7 @@ func (c *Client) TestRequestNumberInt64ArrayArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7897,14 +7578,14 @@ func (c *Client) TestRequestNumberInt64ArrayArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int64_array_array" + u.Path += "/test_request_number_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt64ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7916,7 +7597,7 @@ func (c *Client) TestRequestNumberInt64ArrayArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt64ArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7924,14 +7605,29 @@ func (c *Client) TestRequestNumberInt64ArrayArray(ctx context.Context, request [ return result, nil } -// TestRequestNumberInt64Nullable invokes test_request_number_int64_nullable operation. +// TestRequestNumberDouble invokes test_request_number_double operation. // -// POST /test_request_number_int64_nullable -func (c *Client) TestRequestNumberInt64Nullable(ctx context.Context, request OptNilInt64) (res Error, err error) { +// POST /test_request_number_double +func (c *Client) TestRequestNumberDouble(ctx context.Context, request OptFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_nullable"), + otelogen.OperationID("test_request_number_double"), } // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -7944,7 +7640,7 @@ func (c *Client) TestRequestNumberInt64Nullable(ctx context.Context, request Opt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDouble", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -7961,14 +7657,14 @@ func (c *Client) TestRequestNumberInt64Nullable(ctx context.Context, request Opt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int64_nullable" + u.Path += "/test_request_number_double" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt64NullableRequest(request, r); err != nil { + if err := encodeTestRequestNumberDoubleRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -7980,7 +7676,7 @@ func (c *Client) TestRequestNumberInt64Nullable(ctx context.Context, request Opt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt64NullableResponse(resp, span) + result, err := decodeTestRequestNumberDoubleResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7988,14 +7684,36 @@ func (c *Client) TestRequestNumberInt64Nullable(ctx context.Context, request Opt return result, nil } -// TestRequestNumberInt64NullableArray invokes test_request_number_int64_nullable_array operation. +// TestRequestNumberDoubleArray invokes test_request_number_double_array operation. // -// POST /test_request_number_int64_nullable_array -func (c *Client) TestRequestNumberInt64NullableArray(ctx context.Context, request []NilInt64) (res Error, err error) { +// POST /test_request_number_double_array +func (c *Client) TestRequestNumberDoubleArray(ctx context.Context, request []float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_nullable_array"), + otelogen.OperationID("test_request_number_double_array"), } // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -8008,7 +7726,7 @@ func (c *Client) TestRequestNumberInt64NullableArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8025,14 +7743,14 @@ func (c *Client) TestRequestNumberInt64NullableArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int64_nullable_array" + u.Path += "/test_request_number_double_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt64NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberDoubleArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8044,7 +7762,7 @@ func (c *Client) TestRequestNumberInt64NullableArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt64NullableArrayResponse(resp, span) + result, err := decodeTestRequestNumberDoubleArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8052,12 +7770,12 @@ func (c *Client) TestRequestNumberInt64NullableArray(ctx context.Context, reques return result, nil } -// TestRequestNumberInt64NullableArrayArray invokes test_request_number_int64_nullable_array_array operation. +// TestRequestNumberDoubleArrayArray invokes test_request_number_double_array_array operation. // -// POST /test_request_number_int64_nullable_array_array -func (c *Client) TestRequestNumberInt64NullableArrayArray(ctx context.Context, request [][]NilInt64) (res Error, err error) { +// POST /test_request_number_double_array_array +func (c *Client) TestRequestNumberDoubleArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_nullable_array_array"), + otelogen.OperationID("test_request_number_double_array_array"), } // Validate request before sending. if err := func() error { @@ -8067,6 +7785,23 @@ func (c *Client) TestRequestNumberInt64NullableArrayArray(ctx context.Context, r if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -8094,7 +7829,7 @@ func (c *Client) TestRequestNumberInt64NullableArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8111,14 +7846,14 @@ func (c *Client) TestRequestNumberInt64NullableArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_int64_nullable_array_array" + u.Path += "/test_request_number_double_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberInt64NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberDoubleArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8130,7 +7865,7 @@ func (c *Client) TestRequestNumberInt64NullableArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberInt64NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberDoubleArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8138,12 +7873,12 @@ func (c *Client) TestRequestNumberInt64NullableArrayArray(ctx context.Context, r return result, nil } -// TestRequestNumberNullable invokes test_request_number_nullable operation. +// TestRequestNumberDoubleNullable invokes test_request_number_double_nullable operation. // -// POST /test_request_number_nullable -func (c *Client) TestRequestNumberNullable(ctx context.Context, request OptNilFloat64) (res Error, err error) { +// POST /test_request_number_double_nullable +func (c *Client) TestRequestNumberDoubleNullable(ctx context.Context, request OptNilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_nullable"), + otelogen.OperationID("test_request_number_double_nullable"), } // Validate request before sending. if err := func() error { @@ -8173,7 +7908,7 @@ func (c *Client) TestRequestNumberNullable(ctx context.Context, request OptNilFl c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8190,14 +7925,14 @@ func (c *Client) TestRequestNumberNullable(ctx context.Context, request OptNilFl stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_nullable" + u.Path += "/test_request_number_double_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberNullableRequest(request, r); err != nil { + if err := encodeTestRequestNumberDoubleNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8209,7 +7944,7 @@ func (c *Client) TestRequestNumberNullable(ctx context.Context, request OptNilFl defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberNullableResponse(resp, span) + result, err := decodeTestRequestNumberDoubleNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8217,12 +7952,12 @@ func (c *Client) TestRequestNumberNullable(ctx context.Context, request OptNilFl return result, nil } -// TestRequestNumberNullableArray invokes test_request_number_nullable_array operation. +// TestRequestNumberDoubleNullableArray invokes test_request_number_double_nullable_array operation. // -// POST /test_request_number_nullable_array -func (c *Client) TestRequestNumberNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { +// POST /test_request_number_double_nullable_array +func (c *Client) TestRequestNumberDoubleNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_nullable_array"), + otelogen.OperationID("test_request_number_double_nullable_array"), } // Validate request before sending. if err := func() error { @@ -8259,7 +7994,7 @@ func (c *Client) TestRequestNumberNullableArray(ctx context.Context, request []N c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8276,14 +8011,14 @@ func (c *Client) TestRequestNumberNullableArray(ctx context.Context, request []N stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_nullable_array" + u.Path += "/test_request_number_double_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberDoubleNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8295,7 +8030,7 @@ func (c *Client) TestRequestNumberNullableArray(ctx context.Context, request []N defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberNullableArrayResponse(resp, span) + result, err := decodeTestRequestNumberDoubleNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8303,12 +8038,12 @@ func (c *Client) TestRequestNumberNullableArray(ctx context.Context, request []N return result, nil } -// TestRequestNumberNullableArrayArray invokes test_request_number_nullable_array_array operation. +// TestRequestNumberDoubleNullableArrayArray invokes test_request_number_double_nullable_array_array operation. // -// POST /test_request_number_nullable_array_array -func (c *Client) TestRequestNumberNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { +// POST /test_request_number_double_nullable_array_array +func (c *Client) TestRequestNumberDoubleNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_nullable_array_array"), + otelogen.OperationID("test_request_number_double_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -8362,7 +8097,7 @@ func (c *Client) TestRequestNumberNullableArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberDoubleNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8379,14 +8114,14 @@ func (c *Client) TestRequestNumberNullableArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_number_nullable_array_array" + u.Path += "/test_request_number_double_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestNumberNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberDoubleNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8398,7 +8133,7 @@ func (c *Client) TestRequestNumberNullableArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestNumberNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberDoubleNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8406,14 +8141,29 @@ func (c *Client) TestRequestNumberNullableArrayArray(ctx context.Context, reques return result, nil } -// TestRequestRequiredAny invokes test_request_required_Any operation. +// TestRequestNumberFloat invokes test_request_number_float operation. // -// POST /test_request_required_Any -func (c *Client) TestRequestRequiredAny(ctx context.Context, request jx.Raw) (res Error, err error) { +// POST /test_request_number_float +func (c *Client) TestRequestNumberFloat(ctx context.Context, request OptFloat32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_Any"), + otelogen.OperationID("test_request_number_float"), } // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -8426,7 +8176,7 @@ func (c *Client) TestRequestRequiredAny(ctx context.Context, request jx.Raw) (re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredAny", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloat", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8443,14 +8193,14 @@ func (c *Client) TestRequestRequiredAny(ctx context.Context, request jx.Raw) (re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_Any" + u.Path += "/test_request_number_float" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredAnyRequest(request, r); err != nil { + if err := encodeTestRequestNumberFloatRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8462,7 +8212,7 @@ func (c *Client) TestRequestRequiredAny(ctx context.Context, request jx.Raw) (re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredAnyResponse(resp, span) + result, err := decodeTestRequestNumberFloatResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8470,14 +8220,36 @@ func (c *Client) TestRequestRequiredAny(ctx context.Context, request jx.Raw) (re return result, nil } -// TestRequestRequiredBoolean invokes test_request_required_boolean operation. +// TestRequestNumberFloatArray invokes test_request_number_float_array operation. // -// POST /test_request_required_boolean -func (c *Client) TestRequestRequiredBoolean(ctx context.Context, request bool) (res Error, err error) { +// POST /test_request_number_float_array +func (c *Client) TestRequestNumberFloatArray(ctx context.Context, request []float32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean"), + otelogen.OperationID("test_request_number_float_array"), } // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -8490,7 +8262,7 @@ func (c *Client) TestRequestRequiredBoolean(ctx context.Context, request bool) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBoolean", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8507,14 +8279,14 @@ func (c *Client) TestRequestRequiredBoolean(ctx context.Context, request bool) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_boolean" + u.Path += "/test_request_number_float_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredBooleanRequest(request, r); err != nil { + if err := encodeTestRequestNumberFloatArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8526,7 +8298,7 @@ func (c *Client) TestRequestRequiredBoolean(ctx context.Context, request bool) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredBooleanResponse(resp, span) + result, err := decodeTestRequestNumberFloatArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8534,17 +8306,48 @@ func (c *Client) TestRequestRequiredBoolean(ctx context.Context, request bool) ( return result, nil } -// TestRequestRequiredBooleanArray invokes test_request_required_boolean_array operation. +// TestRequestNumberFloatArrayArray invokes test_request_number_float_array_array operation. // -// POST /test_request_required_boolean_array -func (c *Client) TestRequestRequiredBooleanArray(ctx context.Context, request []bool) (res Error, err error) { +// POST /test_request_number_float_array_array +func (c *Client) TestRequestNumberFloatArrayArray(ctx context.Context, request [][]float32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_array"), + otelogen.OperationID("test_request_number_float_array_array"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} } return nil }(); err != nil { @@ -8562,7 +8365,7 @@ func (c *Client) TestRequestRequiredBooleanArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8579,14 +8382,14 @@ func (c *Client) TestRequestRequiredBooleanArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_boolean_array" + u.Path += "/test_request_number_float_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredBooleanArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberFloatArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8598,7 +8401,7 @@ func (c *Client) TestRequestRequiredBooleanArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredBooleanArrayResponse(resp, span) + result, err := decodeTestRequestNumberFloatArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8606,23 +8409,99 @@ func (c *Client) TestRequestRequiredBooleanArray(ctx context.Context, request [] return result, nil } -// TestRequestRequiredBooleanArrayArray invokes test_request_required_boolean_array_array operation. +// TestRequestNumberFloatNullable invokes test_request_number_float_nullable operation. // -// POST /test_request_required_boolean_array_array -func (c *Client) TestRequestRequiredBooleanArrayArray(ctx context.Context, request [][]bool) (res Error, err error) { +// POST /test_request_number_float_nullable +func (c *Client) TestRequestNumberFloatNullable(ctx context.Context, request OptNilFloat32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_array_array"), + otelogen.OperationID("test_request_number_float_nullable"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_number_float_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestNumberFloatNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestNumberFloatNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestNumberFloatNullableArray invokes test_request_number_float_nullable_array operation. +// +// POST /test_request_number_float_nullable_array +func (c *Client) TestRequestNumberFloatNullableArray(ctx context.Context, request []NilFloat32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_number_float_nullable_array"), + } + // Validate request before sending. + if err := func() error { var failures []validate.FieldError for i, elem := range request { if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") } return nil }(); err != nil { @@ -8651,71 +8530,7 @@ func (c *Client) TestRequestRequiredBooleanArrayArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanArrayArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), - ) - // Track stage for error reporting. - var stage string - defer func() { - if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - c.errors.Add(ctx, 1, otelAttrs...) - } - span.End() - }() - - stage = "BuildURL" - u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_boolean_array_array" - - stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "POST", u, nil) - if err != nil { - return res, errors.Wrap(err, "create request") - } - if err := encodeTestRequestRequiredBooleanArrayArrayRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") - } - - stage = "SendRequest" - resp, err := c.cfg.Client.Do(r) - if err != nil { - return res, errors.Wrap(err, "do request") - } - defer resp.Body.Close() - - stage = "DecodeResponse" - result, err := decodeTestRequestRequiredBooleanArrayArrayResponse(resp, span) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// TestRequestRequiredBooleanNullable invokes test_request_required_boolean_nullable operation. -// -// POST /test_request_required_boolean_nullable -func (c *Client) TestRequestRequiredBooleanNullable(ctx context.Context, request NilBool) (res Error, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_nullable"), - } - // Validate request before sending. - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - c.requests.Add(ctx, 1, otelAttrs...) - - // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8732,14 +8547,14 @@ func (c *Client) TestRequestRequiredBooleanNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_boolean_nullable" + u.Path += "/test_request_number_float_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredBooleanNullableRequest(request, r); err != nil { + if err := encodeTestRequestNumberFloatNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8751,7 +8566,7 @@ func (c *Client) TestRequestRequiredBooleanNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredBooleanNullableResponse(resp, span) + result, err := decodeTestRequestNumberFloatNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8759,17 +8574,48 @@ func (c *Client) TestRequestRequiredBooleanNullable(ctx context.Context, request return result, nil } -// TestRequestRequiredBooleanNullableArray invokes test_request_required_boolean_nullable_array operation. +// TestRequestNumberFloatNullableArrayArray invokes test_request_number_float_nullable_array_array operation. // -// POST /test_request_required_boolean_nullable_array -func (c *Client) TestRequestRequiredBooleanNullableArray(ctx context.Context, request []NilBool) (res Error, err error) { +// POST /test_request_number_float_nullable_array_array +func (c *Client) TestRequestNumberFloatNullableArrayArray(ctx context.Context, request [][]NilFloat32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_nullable_array"), + otelogen.OperationID("test_request_number_float_nullable_array_array"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} } return nil }(); err != nil { @@ -8787,7 +8633,7 @@ func (c *Client) TestRequestRequiredBooleanNullableArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberFloatNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8804,14 +8650,14 @@ func (c *Client) TestRequestRequiredBooleanNullableArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_boolean_nullable_array" + u.Path += "/test_request_number_float_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredBooleanNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberFloatNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8823,7 +8669,7 @@ func (c *Client) TestRequestRequiredBooleanNullableArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredBooleanNullableArrayResponse(resp, span) + result, err := decodeTestRequestNumberFloatNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8831,39 +8677,14 @@ func (c *Client) TestRequestRequiredBooleanNullableArray(ctx context.Context, re return result, nil } -// TestRequestRequiredBooleanNullableArrayArray invokes test_request_required_boolean_nullable_array_array operation. +// TestRequestNumberInt32 invokes test_request_number_int32 operation. // -// POST /test_request_required_boolean_nullable_array_array -func (c *Client) TestRequestRequiredBooleanNullableArrayArray(ctx context.Context, request [][]NilBool) (res Error, err error) { +// POST /test_request_number_int32 +func (c *Client) TestRequestNumberInt32(ctx context.Context, request OptInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_nullable_array_array"), + otelogen.OperationID("test_request_number_int32"), } // Validate request before sending. - if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -8876,7 +8697,7 @@ func (c *Client) TestRequestRequiredBooleanNullableArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8893,14 +8714,14 @@ func (c *Client) TestRequestRequiredBooleanNullableArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_boolean_nullable_array_array" + u.Path += "/test_request_number_int32" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredBooleanNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt32Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8912,7 +8733,7 @@ func (c *Client) TestRequestRequiredBooleanNullableArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredBooleanNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberInt32Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8920,12 +8741,12 @@ func (c *Client) TestRequestRequiredBooleanNullableArrayArray(ctx context.Contex return result, nil } -// TestRequestRequiredEmptyStruct invokes test_request_required_EmptyStruct operation. +// TestRequestNumberInt32Array invokes test_request_number_int32_array operation. // -// POST /test_request_required_EmptyStruct -func (c *Client) TestRequestRequiredEmptyStruct(ctx context.Context, request TestRequestRequiredEmptyStructReq) (res Error, err error) { +// POST /test_request_number_int32_array +func (c *Client) TestRequestNumberInt32Array(ctx context.Context, request []int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_EmptyStruct"), + otelogen.OperationID("test_request_number_int32_array"), } // Validate request before sending. @@ -8940,7 +8761,7 @@ func (c *Client) TestRequestRequiredEmptyStruct(ctx context.Context, request Tes c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredEmptyStruct", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -8957,14 +8778,14 @@ func (c *Client) TestRequestRequiredEmptyStruct(ctx context.Context, request Tes stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_EmptyStruct" + u.Path += "/test_request_number_int32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredEmptyStructRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -8976,7 +8797,7 @@ func (c *Client) TestRequestRequiredEmptyStruct(ctx context.Context, request Tes defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredEmptyStructResponse(resp, span) + result, err := decodeTestRequestNumberInt32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8984,17 +8805,31 @@ func (c *Client) TestRequestRequiredEmptyStruct(ctx context.Context, request Tes return result, nil } -// TestRequestRequiredFormatTest invokes test_request_required_FormatTest operation. +// TestRequestNumberInt32ArrayArray invokes test_request_number_int32_array_array operation. // -// POST /test_request_required_FormatTest -func (c *Client) TestRequestRequiredFormatTest(ctx context.Context, request TestRequestRequiredFormatTestReq) (res Error, err error) { +// POST /test_request_number_int32_array_array +func (c *Client) TestRequestNumberInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_FormatTest"), + otelogen.OperationID("test_request_number_int32_array_array"), } // Validate request before sending. if err := func() error { - if err := request.Validate(); err != nil { - return err + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} } return nil }(); err != nil { @@ -9012,7 +8847,7 @@ func (c *Client) TestRequestRequiredFormatTest(ctx context.Context, request Test c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredFormatTest", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9029,14 +8864,14 @@ func (c *Client) TestRequestRequiredFormatTest(ctx context.Context, request Test stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_FormatTest" + u.Path += "/test_request_number_int32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredFormatTestRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9048,7 +8883,7 @@ func (c *Client) TestRequestRequiredFormatTest(ctx context.Context, request Test defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredFormatTestResponse(resp, span) + result, err := decodeTestRequestNumberInt32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9056,12 +8891,12 @@ func (c *Client) TestRequestRequiredFormatTest(ctx context.Context, request Test return result, nil } -// TestRequestRequiredInteger invokes test_request_required_integer operation. +// TestRequestNumberInt32Nullable invokes test_request_number_int32_nullable operation. // -// POST /test_request_required_integer -func (c *Client) TestRequestRequiredInteger(ctx context.Context, request int) (res Error, err error) { +// POST /test_request_number_int32_nullable +func (c *Client) TestRequestNumberInt32Nullable(ctx context.Context, request OptNilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer"), + otelogen.OperationID("test_request_number_int32_nullable"), } // Validate request before sending. @@ -9076,7 +8911,7 @@ func (c *Client) TestRequestRequiredInteger(ctx context.Context, request int) (r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredInteger", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9093,14 +8928,14 @@ func (c *Client) TestRequestRequiredInteger(ctx context.Context, request int) (r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer" + u.Path += "/test_request_number_int32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9112,7 +8947,7 @@ func (c *Client) TestRequestRequiredInteger(ctx context.Context, request int) (r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerResponse(resp, span) + result, err := decodeTestRequestNumberInt32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9120,22 +8955,14 @@ func (c *Client) TestRequestRequiredInteger(ctx context.Context, request int) (r return result, nil } -// TestRequestRequiredIntegerArray invokes test_request_required_integer_array operation. +// TestRequestNumberInt32NullableArray invokes test_request_number_int32_nullable_array operation. // -// POST /test_request_required_integer_array -func (c *Client) TestRequestRequiredIntegerArray(ctx context.Context, request []int) (res Error, err error) { +// POST /test_request_number_int32_nullable_array +func (c *Client) TestRequestNumberInt32NullableArray(ctx context.Context, request []NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_array"), + otelogen.OperationID("test_request_number_int32_nullable_array"), } // Validate request before sending. - if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -9148,7 +8975,7 @@ func (c *Client) TestRequestRequiredIntegerArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9165,14 +8992,14 @@ func (c *Client) TestRequestRequiredIntegerArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_array" + u.Path += "/test_request_number_int32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9184,7 +9011,7 @@ func (c *Client) TestRequestRequiredIntegerArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerArrayResponse(resp, span) + result, err := decodeTestRequestNumberInt32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9192,18 +9019,15 @@ func (c *Client) TestRequestRequiredIntegerArray(ctx context.Context, request [] return result, nil } -// TestRequestRequiredIntegerArrayArray invokes test_request_required_integer_array_array operation. +// TestRequestNumberInt32NullableArrayArray invokes test_request_number_int32_nullable_array_array operation. // -// POST /test_request_required_integer_array_array -func (c *Client) TestRequestRequiredIntegerArrayArray(ctx context.Context, request [][]int) (res Error, err error) { +// POST /test_request_number_int32_nullable_array_array +func (c *Client) TestRequestNumberInt32NullableArrayArray(ctx context.Context, request [][]NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_array_array"), + otelogen.OperationID("test_request_number_int32_nullable_array_array"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -9237,7 +9061,7 @@ func (c *Client) TestRequestRequiredIntegerArrayArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9254,14 +9078,14 @@ func (c *Client) TestRequestRequiredIntegerArrayArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_array_array" + u.Path += "/test_request_number_int32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9273,7 +9097,7 @@ func (c *Client) TestRequestRequiredIntegerArrayArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberInt32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9281,12 +9105,12 @@ func (c *Client) TestRequestRequiredIntegerArrayArray(ctx context.Context, reque return result, nil } -// TestRequestRequiredIntegerInt32 invokes test_request_required_integer_int32 operation. +// TestRequestNumberInt64 invokes test_request_number_int64 operation. // -// POST /test_request_required_integer_int32 -func (c *Client) TestRequestRequiredIntegerInt32(ctx context.Context, request int32) (res Error, err error) { +// POST /test_request_number_int64 +func (c *Client) TestRequestNumberInt64(ctx context.Context, request OptInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32"), + otelogen.OperationID("test_request_number_int64"), } // Validate request before sending. @@ -9301,7 +9125,7 @@ func (c *Client) TestRequestRequiredIntegerInt32(ctx context.Context, request in c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9318,14 +9142,14 @@ func (c *Client) TestRequestRequiredIntegerInt32(ctx context.Context, request in stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int32" + u.Path += "/test_request_number_int64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt32Request(request, r); err != nil { + if err := encodeTestRequestNumberInt64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9337,7 +9161,7 @@ func (c *Client) TestRequestRequiredIntegerInt32(ctx context.Context, request in defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt32Response(resp, span) + result, err := decodeTestRequestNumberInt64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9345,22 +9169,14 @@ func (c *Client) TestRequestRequiredIntegerInt32(ctx context.Context, request in return result, nil } -// TestRequestRequiredIntegerInt32Array invokes test_request_required_integer_int32_array operation. +// TestRequestNumberInt64Array invokes test_request_number_int64_array operation. // -// POST /test_request_required_integer_int32_array -func (c *Client) TestRequestRequiredIntegerInt32Array(ctx context.Context, request []int32) (res Error, err error) { +// POST /test_request_number_int64_array +func (c *Client) TestRequestNumberInt64Array(ctx context.Context, request []int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_array"), + otelogen.OperationID("test_request_number_int64_array"), } // Validate request before sending. - if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -9373,7 +9189,7 @@ func (c *Client) TestRequestRequiredIntegerInt32Array(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9390,14 +9206,14 @@ func (c *Client) TestRequestRequiredIntegerInt32Array(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int32_array" + u.Path += "/test_request_number_int64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt32ArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9409,7 +9225,7 @@ func (c *Client) TestRequestRequiredIntegerInt32Array(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt32ArrayResponse(resp, span) + result, err := decodeTestRequestNumberInt64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9417,18 +9233,15 @@ func (c *Client) TestRequestRequiredIntegerInt32Array(ctx context.Context, reque return result, nil } -// TestRequestRequiredIntegerInt32ArrayArray invokes test_request_required_integer_int32_array_array operation. +// TestRequestNumberInt64ArrayArray invokes test_request_number_int64_array_array operation. // -// POST /test_request_required_integer_int32_array_array -func (c *Client) TestRequestRequiredIntegerInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { +// POST /test_request_number_int64_array_array +func (c *Client) TestRequestNumberInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_array_array"), + otelogen.OperationID("test_request_number_int64_array_array"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -9462,7 +9275,7 @@ func (c *Client) TestRequestRequiredIntegerInt32ArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9479,14 +9292,14 @@ func (c *Client) TestRequestRequiredIntegerInt32ArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int32_array_array" + u.Path += "/test_request_number_int64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt32ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9498,7 +9311,7 @@ func (c *Client) TestRequestRequiredIntegerInt32ArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt32ArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberInt64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9506,12 +9319,12 @@ func (c *Client) TestRequestRequiredIntegerInt32ArrayArray(ctx context.Context, return result, nil } -// TestRequestRequiredIntegerInt32Nullable invokes test_request_required_integer_int32_nullable operation. +// TestRequestNumberInt64Nullable invokes test_request_number_int64_nullable operation. // -// POST /test_request_required_integer_int32_nullable -func (c *Client) TestRequestRequiredIntegerInt32Nullable(ctx context.Context, request NilInt32) (res Error, err error) { +// POST /test_request_number_int64_nullable +func (c *Client) TestRequestNumberInt64Nullable(ctx context.Context, request OptNilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_nullable"), + otelogen.OperationID("test_request_number_int64_nullable"), } // Validate request before sending. @@ -9526,7 +9339,7 @@ func (c *Client) TestRequestRequiredIntegerInt32Nullable(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9543,14 +9356,14 @@ func (c *Client) TestRequestRequiredIntegerInt32Nullable(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int32_nullable" + u.Path += "/test_request_number_int64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt32NullableRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9562,7 +9375,7 @@ func (c *Client) TestRequestRequiredIntegerInt32Nullable(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt32NullableResponse(resp, span) + result, err := decodeTestRequestNumberInt64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9570,22 +9383,14 @@ func (c *Client) TestRequestRequiredIntegerInt32Nullable(ctx context.Context, re return result, nil } -// TestRequestRequiredIntegerInt32NullableArray invokes test_request_required_integer_int32_nullable_array operation. +// TestRequestNumberInt64NullableArray invokes test_request_number_int64_nullable_array operation. // -// POST /test_request_required_integer_int32_nullable_array -func (c *Client) TestRequestRequiredIntegerInt32NullableArray(ctx context.Context, request []NilInt32) (res Error, err error) { +// POST /test_request_number_int64_nullable_array +func (c *Client) TestRequestNumberInt64NullableArray(ctx context.Context, request []NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_nullable_array"), + otelogen.OperationID("test_request_number_int64_nullable_array"), } // Validate request before sending. - if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -9598,7 +9403,7 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9615,14 +9420,14 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int32_nullable_array" + u.Path += "/test_request_number_int64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt32NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9634,7 +9439,7 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt32NullableArrayResponse(resp, span) + result, err := decodeTestRequestNumberInt64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9642,18 +9447,15 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArray(ctx context.Contex return result, nil } -// TestRequestRequiredIntegerInt32NullableArrayArray invokes test_request_required_integer_int32_nullable_array_array operation. +// TestRequestNumberInt64NullableArrayArray invokes test_request_number_int64_nullable_array_array operation. // -// POST /test_request_required_integer_int32_nullable_array_array -func (c *Client) TestRequestRequiredIntegerInt32NullableArrayArray(ctx context.Context, request [][]NilInt32) (res Error, err error) { +// POST /test_request_number_int64_nullable_array_array +func (c *Client) TestRequestNumberInt64NullableArrayArray(ctx context.Context, request [][]NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_nullable_array_array"), + otelogen.OperationID("test_request_number_int64_nullable_array_array"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -9687,7 +9489,7 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArrayArray(ctx context.C c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9704,14 +9506,14 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArrayArray(ctx context.C stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int32_nullable_array_array" + u.Path += "/test_request_number_int64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberInt64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9723,7 +9525,7 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArrayArray(ctx context.C defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberInt64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9731,14 +9533,29 @@ func (c *Client) TestRequestRequiredIntegerInt32NullableArrayArray(ctx context.C return result, nil } -// TestRequestRequiredIntegerInt64 invokes test_request_required_integer_int64 operation. +// TestRequestNumberNullable invokes test_request_number_nullable operation. // -// POST /test_request_required_integer_int64 -func (c *Client) TestRequestRequiredIntegerInt64(ctx context.Context, request int64) (res Error, err error) { +// POST /test_request_number_nullable +func (c *Client) TestRequestNumberNullable(ctx context.Context, request OptNilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64"), + otelogen.OperationID("test_request_number_nullable"), } // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -9751,7 +9568,7 @@ func (c *Client) TestRequestRequiredIntegerInt64(ctx context.Context, request in c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9768,14 +9585,14 @@ func (c *Client) TestRequestRequiredIntegerInt64(ctx context.Context, request in stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int64" + u.Path += "/test_request_number_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt64Request(request, r); err != nil { + if err := encodeTestRequestNumberNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9787,7 +9604,7 @@ func (c *Client) TestRequestRequiredIntegerInt64(ctx context.Context, request in defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt64Response(resp, span) + result, err := decodeTestRequestNumberNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9795,17 +9612,31 @@ func (c *Client) TestRequestRequiredIntegerInt64(ctx context.Context, request in return result, nil } -// TestRequestRequiredIntegerInt64Array invokes test_request_required_integer_int64_array operation. +// TestRequestNumberNullableArray invokes test_request_number_nullable_array operation. // -// POST /test_request_required_integer_int64_array -func (c *Client) TestRequestRequiredIntegerInt64Array(ctx context.Context, request []int64) (res Error, err error) { +// POST /test_request_number_nullable_array +func (c *Client) TestRequestNumberNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_array"), + otelogen.OperationID("test_request_number_nullable_array"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} } return nil }(); err != nil { @@ -9823,7 +9654,7 @@ func (c *Client) TestRequestRequiredIntegerInt64Array(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9840,14 +9671,14 @@ func (c *Client) TestRequestRequiredIntegerInt64Array(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int64_array" + u.Path += "/test_request_number_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt64ArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9859,7 +9690,7 @@ func (c *Client) TestRequestRequiredIntegerInt64Array(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt64ArrayResponse(resp, span) + result, err := decodeTestRequestNumberNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9867,24 +9698,38 @@ func (c *Client) TestRequestRequiredIntegerInt64Array(ctx context.Context, reque return result, nil } -// TestRequestRequiredIntegerInt64ArrayArray invokes test_request_required_integer_int64_array_array operation. +// TestRequestNumberNullableArrayArray invokes test_request_number_nullable_array_array operation. // -// POST /test_request_required_integer_int64_array_array -func (c *Client) TestRequestRequiredIntegerInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { +// POST /test_request_number_nullable_array_array +func (c *Client) TestRequestNumberNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_array_array"), + otelogen.OperationID("test_request_number_nullable_array_array"), } // Validate request before sending. if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } var failures []validate.FieldError for i, elem := range request { if err := func() error { if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -9912,7 +9757,7 @@ func (c *Client) TestRequestRequiredIntegerInt64ArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestNumberNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9929,14 +9774,14 @@ func (c *Client) TestRequestRequiredIntegerInt64ArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int64_array_array" + u.Path += "/test_request_number_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt64ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestNumberNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -9948,7 +9793,7 @@ func (c *Client) TestRequestRequiredIntegerInt64ArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt64ArrayArrayResponse(resp, span) + result, err := decodeTestRequestNumberNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -9956,12 +9801,12 @@ func (c *Client) TestRequestRequiredIntegerInt64ArrayArray(ctx context.Context, return result, nil } -// TestRequestRequiredIntegerInt64Nullable invokes test_request_required_integer_int64_nullable operation. +// TestRequestRequiredAny invokes test_request_required_Any operation. // -// POST /test_request_required_integer_int64_nullable -func (c *Client) TestRequestRequiredIntegerInt64Nullable(ctx context.Context, request NilInt64) (res Error, err error) { +// POST /test_request_required_Any +func (c *Client) TestRequestRequiredAny(ctx context.Context, request jx.Raw) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_nullable"), + otelogen.OperationID("test_request_required_Any"), } // Validate request before sending. @@ -9976,7 +9821,7 @@ func (c *Client) TestRequestRequiredIntegerInt64Nullable(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredAny", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -9993,14 +9838,14 @@ func (c *Client) TestRequestRequiredIntegerInt64Nullable(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int64_nullable" + u.Path += "/test_request_required_Any" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt64NullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredAnyRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10012,7 +9857,7 @@ func (c *Client) TestRequestRequiredIntegerInt64Nullable(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt64NullableResponse(resp, span) + result, err := decodeTestRequestRequiredAnyResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10020,12 +9865,76 @@ func (c *Client) TestRequestRequiredIntegerInt64Nullable(ctx context.Context, re return result, nil } -// TestRequestRequiredIntegerInt64NullableArray invokes test_request_required_integer_int64_nullable_array operation. +// TestRequestRequiredBoolean invokes test_request_required_boolean operation. // -// POST /test_request_required_integer_int64_nullable_array -func (c *Client) TestRequestRequiredIntegerInt64NullableArray(ctx context.Context, request []NilInt64) (res Error, err error) { +// POST /test_request_required_boolean +func (c *Client) TestRequestRequiredBoolean(ctx context.Context, request bool) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_nullable_array"), + otelogen.OperationID("test_request_required_boolean"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBoolean", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_required_boolean" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredBooleanRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestRequiredBooleanResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredBooleanArray invokes test_request_required_boolean_array operation. +// +// POST /test_request_required_boolean_array +func (c *Client) TestRequestRequiredBooleanArray(ctx context.Context, request []bool) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_boolean_array"), } // Validate request before sending. if err := func() error { @@ -10048,7 +9957,7 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10065,14 +9974,14 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int64_nullable_array" + u.Path += "/test_request_required_boolean_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt64NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredBooleanArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10084,7 +9993,7 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt64NullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredBooleanArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10092,12 +10001,12 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArray(ctx context.Contex return result, nil } -// TestRequestRequiredIntegerInt64NullableArrayArray invokes test_request_required_integer_int64_nullable_array_array operation. +// TestRequestRequiredBooleanArrayArray invokes test_request_required_boolean_array_array operation. // -// POST /test_request_required_integer_int64_nullable_array_array -func (c *Client) TestRequestRequiredIntegerInt64NullableArrayArray(ctx context.Context, request [][]NilInt64) (res Error, err error) { +// POST /test_request_required_boolean_array_array +func (c *Client) TestRequestRequiredBooleanArrayArray(ctx context.Context, request [][]bool) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_nullable_array_array"), + otelogen.OperationID("test_request_required_boolean_array_array"), } // Validate request before sending. if err := func() error { @@ -10137,7 +10046,7 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArrayArray(ctx context.C c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10154,14 +10063,14 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArrayArray(ctx context.C stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_int64_nullable_array_array" + u.Path += "/test_request_required_boolean_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredBooleanArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10173,7 +10082,7 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArrayArray(ctx context.C defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredBooleanArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10181,12 +10090,12 @@ func (c *Client) TestRequestRequiredIntegerInt64NullableArrayArray(ctx context.C return result, nil } -// TestRequestRequiredIntegerNullable invokes test_request_required_integer_nullable operation. +// TestRequestRequiredBooleanNullable invokes test_request_required_boolean_nullable operation. // -// POST /test_request_required_integer_nullable -func (c *Client) TestRequestRequiredIntegerNullable(ctx context.Context, request NilInt) (res Error, err error) { +// POST /test_request_required_boolean_nullable +func (c *Client) TestRequestRequiredBooleanNullable(ctx context.Context, request NilBool) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_nullable"), + otelogen.OperationID("test_request_required_boolean_nullable"), } // Validate request before sending. @@ -10201,7 +10110,7 @@ func (c *Client) TestRequestRequiredIntegerNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10218,14 +10127,14 @@ func (c *Client) TestRequestRequiredIntegerNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_nullable" + u.Path += "/test_request_required_boolean_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredBooleanNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10237,7 +10146,7 @@ func (c *Client) TestRequestRequiredIntegerNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerNullableResponse(resp, span) + result, err := decodeTestRequestRequiredBooleanNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10245,12 +10154,12 @@ func (c *Client) TestRequestRequiredIntegerNullable(ctx context.Context, request return result, nil } -// TestRequestRequiredIntegerNullableArray invokes test_request_required_integer_nullable_array operation. +// TestRequestRequiredBooleanNullableArray invokes test_request_required_boolean_nullable_array operation. // -// POST /test_request_required_integer_nullable_array -func (c *Client) TestRequestRequiredIntegerNullableArray(ctx context.Context, request []NilInt) (res Error, err error) { +// POST /test_request_required_boolean_nullable_array +func (c *Client) TestRequestRequiredBooleanNullableArray(ctx context.Context, request []NilBool) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_nullable_array"), + otelogen.OperationID("test_request_required_boolean_nullable_array"), } // Validate request before sending. if err := func() error { @@ -10273,7 +10182,7 @@ func (c *Client) TestRequestRequiredIntegerNullableArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10290,14 +10199,14 @@ func (c *Client) TestRequestRequiredIntegerNullableArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_nullable_array" + u.Path += "/test_request_required_boolean_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredBooleanNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10309,7 +10218,7 @@ func (c *Client) TestRequestRequiredIntegerNullableArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredBooleanNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10317,12 +10226,12 @@ func (c *Client) TestRequestRequiredIntegerNullableArray(ctx context.Context, re return result, nil } -// TestRequestRequiredIntegerNullableArrayArray invokes test_request_required_integer_nullable_array_array operation. +// TestRequestRequiredBooleanNullableArrayArray invokes test_request_required_boolean_nullable_array_array operation. // -// POST /test_request_required_integer_nullable_array_array -func (c *Client) TestRequestRequiredIntegerNullableArrayArray(ctx context.Context, request [][]NilInt) (res Error, err error) { +// POST /test_request_required_boolean_nullable_array_array +func (c *Client) TestRequestRequiredBooleanNullableArrayArray(ctx context.Context, request [][]NilBool) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_nullable_array_array"), + otelogen.OperationID("test_request_required_boolean_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -10362,7 +10271,7 @@ func (c *Client) TestRequestRequiredIntegerNullableArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredBooleanNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10379,14 +10288,14 @@ func (c *Client) TestRequestRequiredIntegerNullableArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_nullable_array_array" + u.Path += "/test_request_required_boolean_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredBooleanNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10398,7 +10307,7 @@ func (c *Client) TestRequestRequiredIntegerNullableArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredBooleanNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10406,12 +10315,12 @@ func (c *Client) TestRequestRequiredIntegerNullableArrayArray(ctx context.Contex return result, nil } -// TestRequestRequiredIntegerUnix invokes test_request_required_integer_unix operation. +// TestRequestRequiredEmptyStruct invokes test_request_required_EmptyStruct operation. // -// POST /test_request_required_integer_unix -func (c *Client) TestRequestRequiredIntegerUnix(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_EmptyStruct +func (c *Client) TestRequestRequiredEmptyStruct(ctx context.Context, request TestRequestRequiredEmptyStructReq) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix"), + otelogen.OperationID("test_request_required_EmptyStruct"), } // Validate request before sending. @@ -10426,7 +10335,7 @@ func (c *Client) TestRequestRequiredIntegerUnix(ctx context.Context, request tim c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnix", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredEmptyStruct", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10443,14 +10352,14 @@ func (c *Client) TestRequestRequiredIntegerUnix(ctx context.Context, request tim stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix" + u.Path += "/test_request_required_EmptyStruct" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixRequest(request, r); err != nil { + if err := encodeTestRequestRequiredEmptyStructRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10462,7 +10371,7 @@ func (c *Client) TestRequestRequiredIntegerUnix(ctx context.Context, request tim defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixResponse(resp, span) + result, err := decodeTestRequestRequiredEmptyStructResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10470,12 +10379,148 @@ func (c *Client) TestRequestRequiredIntegerUnix(ctx context.Context, request tim return result, nil } -// TestRequestRequiredIntegerUnixArray invokes test_request_required_integer_unix_array operation. +// TestRequestRequiredFormatTest invokes test_request_required_FormatTest operation. // -// POST /test_request_required_integer_unix_array -func (c *Client) TestRequestRequiredIntegerUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_FormatTest +func (c *Client) TestRequestRequiredFormatTest(ctx context.Context, request TestRequestRequiredFormatTestReq) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_array"), + otelogen.OperationID("test_request_required_FormatTest"), + } + // Validate request before sending. + if err := func() error { + if err := request.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredFormatTest", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_required_FormatTest" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredFormatTestRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestRequiredFormatTestResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredInteger invokes test_request_required_integer operation. +// +// POST /test_request_required_integer +func (c *Client) TestRequestRequiredInteger(ctx context.Context, request int) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_integer"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredInteger", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_required_integer" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredIntegerRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestRequiredIntegerResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredIntegerArray invokes test_request_required_integer_array operation. +// +// POST /test_request_required_integer_array +func (c *Client) TestRequestRequiredIntegerArray(ctx context.Context, request []int) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_integer_array"), } // Validate request before sending. if err := func() error { @@ -10498,7 +10543,7 @@ func (c *Client) TestRequestRequiredIntegerUnixArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10515,14 +10560,14 @@ func (c *Client) TestRequestRequiredIntegerUnixArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix_array" + u.Path += "/test_request_required_integer_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10534,7 +10579,7 @@ func (c *Client) TestRequestRequiredIntegerUnixArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10542,12 +10587,12 @@ func (c *Client) TestRequestRequiredIntegerUnixArray(ctx context.Context, reques return result, nil } -// TestRequestRequiredIntegerUnixArrayArray invokes test_request_required_integer_unix_array_array operation. +// TestRequestRequiredIntegerArrayArray invokes test_request_required_integer_array_array operation. // -// POST /test_request_required_integer_unix_array_array -func (c *Client) TestRequestRequiredIntegerUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_integer_array_array +func (c *Client) TestRequestRequiredIntegerArrayArray(ctx context.Context, request [][]int) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_array_array"), + otelogen.OperationID("test_request_required_integer_array_array"), } // Validate request before sending. if err := func() error { @@ -10587,7 +10632,7 @@ func (c *Client) TestRequestRequiredIntegerUnixArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10604,14 +10649,14 @@ func (c *Client) TestRequestRequiredIntegerUnixArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix_array_array" + u.Path += "/test_request_required_integer_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10623,7 +10668,7 @@ func (c *Client) TestRequestRequiredIntegerUnixArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10631,12 +10676,12 @@ func (c *Client) TestRequestRequiredIntegerUnixArrayArray(ctx context.Context, r return result, nil } -// TestRequestRequiredIntegerUnixMicro invokes test_request_required_integer_unix-micro operation. +// TestRequestRequiredIntegerInt32 invokes test_request_required_integer_int32 operation. // -// POST /test_request_required_integer_unix-micro -func (c *Client) TestRequestRequiredIntegerUnixMicro(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_integer_int32 +func (c *Client) TestRequestRequiredIntegerInt32(ctx context.Context, request int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro"), + otelogen.OperationID("test_request_required_integer_int32"), } // Validate request before sending. @@ -10651,7 +10696,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicro(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicro", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10668,14 +10713,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMicro(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-micro" + u.Path += "/test_request_required_integer_int32" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMicroRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt32Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10687,7 +10732,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicro(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMicroResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt32Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10695,12 +10740,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMicro(ctx context.Context, reques return result, nil } -// TestRequestRequiredIntegerUnixMicroArray invokes test_request_required_integer_unix-micro_array operation. +// TestRequestRequiredIntegerInt32Array invokes test_request_required_integer_int32_array operation. // -// POST /test_request_required_integer_unix-micro_array -func (c *Client) TestRequestRequiredIntegerUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_integer_int32_array +func (c *Client) TestRequestRequiredIntegerInt32Array(ctx context.Context, request []int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_array"), + otelogen.OperationID("test_request_required_integer_int32_array"), } // Validate request before sending. if err := func() error { @@ -10723,7 +10768,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10740,14 +10785,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-micro_array" + u.Path += "/test_request_required_integer_int32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMicroArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10759,7 +10804,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMicroArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10767,12 +10812,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArray(ctx context.Context, r return result, nil } -// TestRequestRequiredIntegerUnixMicroArrayArray invokes test_request_required_integer_unix-micro_array_array operation. +// TestRequestRequiredIntegerInt32ArrayArray invokes test_request_required_integer_int32_array_array operation. // -// POST /test_request_required_integer_unix-micro_array_array -func (c *Client) TestRequestRequiredIntegerUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_integer_int32_array_array +func (c *Client) TestRequestRequiredIntegerInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_array_array"), + otelogen.OperationID("test_request_required_integer_int32_array_array"), } // Validate request before sending. if err := func() error { @@ -10812,7 +10857,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArrayArray(ctx context.Conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10829,14 +10874,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArrayArray(ctx context.Conte stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-micro_array_array" + u.Path += "/test_request_required_integer_int32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10848,7 +10893,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArrayArray(ctx context.Conte defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10856,12 +10901,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroArrayArray(ctx context.Conte return result, nil } -// TestRequestRequiredIntegerUnixMicroNullable invokes test_request_required_integer_unix-micro_nullable operation. +// TestRequestRequiredIntegerInt32Nullable invokes test_request_required_integer_int32_nullable operation. // -// POST /test_request_required_integer_unix-micro_nullable -func (c *Client) TestRequestRequiredIntegerUnixMicroNullable(ctx context.Context, request NilUnixMicro) (res Error, err error) { +// POST /test_request_required_integer_int32_nullable +func (c *Client) TestRequestRequiredIntegerInt32Nullable(ctx context.Context, request NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_nullable"), + otelogen.OperationID("test_request_required_integer_int32_nullable"), } // Validate request before sending. @@ -10876,7 +10921,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullable(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10893,14 +10938,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullable(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-micro_nullable" + u.Path += "/test_request_required_integer_int32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMicroNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10912,7 +10957,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullable(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMicroNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10920,12 +10965,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullable(ctx context.Context return result, nil } -// TestRequestRequiredIntegerUnixMicroNullableArray invokes test_request_required_integer_unix-micro_nullable_array operation. +// TestRequestRequiredIntegerInt32NullableArray invokes test_request_required_integer_int32_nullable_array operation. // -// POST /test_request_required_integer_unix-micro_nullable_array -func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArray(ctx context.Context, request []NilUnixMicro) (res Error, err error) { +// POST /test_request_required_integer_int32_nullable_array +func (c *Client) TestRequestRequiredIntegerInt32NullableArray(ctx context.Context, request []NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array"), + otelogen.OperationID("test_request_required_integer_int32_nullable_array"), } // Validate request before sending. if err := func() error { @@ -10948,7 +10993,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -10965,14 +11010,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-micro_nullable_array" + u.Path += "/test_request_required_integer_int32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -10984,7 +11029,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10992,12 +11037,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArray(ctx context.Co return result, nil } -// TestRequestRequiredIntegerUnixMicroNullableArrayArray invokes test_request_required_integer_unix-micro_nullable_array_array operation. +// TestRequestRequiredIntegerInt32NullableArrayArray invokes test_request_required_integer_int32_nullable_array_array operation. // -// POST /test_request_required_integer_unix-micro_nullable_array_array -func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx context.Context, request [][]NilUnixMicro) (res Error, err error) { +// POST /test_request_required_integer_int32_nullable_array_array +func (c *Client) TestRequestRequiredIntegerInt32NullableArrayArray(ctx context.Context, request [][]NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_int32_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -11037,7 +11082,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11054,14 +11099,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx conte stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-micro_nullable_array_array" + u.Path += "/test_request_required_integer_int32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11073,7 +11118,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx conte defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11081,12 +11126,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx conte return result, nil } -// TestRequestRequiredIntegerUnixMilli invokes test_request_required_integer_unix-milli operation. +// TestRequestRequiredIntegerInt64 invokes test_request_required_integer_int64 operation. // -// POST /test_request_required_integer_unix-milli -func (c *Client) TestRequestRequiredIntegerUnixMilli(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_integer_int64 +func (c *Client) TestRequestRequiredIntegerInt64(ctx context.Context, request int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli"), + otelogen.OperationID("test_request_required_integer_int64"), } // Validate request before sending. @@ -11101,7 +11146,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilli(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilli", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11118,14 +11163,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMilli(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-milli" + u.Path += "/test_request_required_integer_int64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMilliRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11137,7 +11182,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilli(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMilliResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11145,12 +11190,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMilli(ctx context.Context, reques return result, nil } -// TestRequestRequiredIntegerUnixMilliArray invokes test_request_required_integer_unix-milli_array operation. +// TestRequestRequiredIntegerInt64Array invokes test_request_required_integer_int64_array operation. // -// POST /test_request_required_integer_unix-milli_array -func (c *Client) TestRequestRequiredIntegerUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_integer_int64_array +func (c *Client) TestRequestRequiredIntegerInt64Array(ctx context.Context, request []int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_array"), + otelogen.OperationID("test_request_required_integer_int64_array"), } // Validate request before sending. if err := func() error { @@ -11173,7 +11218,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11190,14 +11235,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-milli_array" + u.Path += "/test_request_required_integer_int64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMilliArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11209,7 +11254,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMilliArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11217,12 +11262,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArray(ctx context.Context, r return result, nil } -// TestRequestRequiredIntegerUnixMilliArrayArray invokes test_request_required_integer_unix-milli_array_array operation. +// TestRequestRequiredIntegerInt64ArrayArray invokes test_request_required_integer_int64_array_array operation. // -// POST /test_request_required_integer_unix-milli_array_array -func (c *Client) TestRequestRequiredIntegerUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_integer_int64_array_array +func (c *Client) TestRequestRequiredIntegerInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_array_array"), + otelogen.OperationID("test_request_required_integer_int64_array_array"), } // Validate request before sending. if err := func() error { @@ -11262,7 +11307,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArrayArray(ctx context.Conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11279,14 +11324,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArrayArray(ctx context.Conte stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-milli_array_array" + u.Path += "/test_request_required_integer_int64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11298,7 +11343,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArrayArray(ctx context.Conte defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11306,12 +11351,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliArrayArray(ctx context.Conte return result, nil } -// TestRequestRequiredIntegerUnixMilliNullable invokes test_request_required_integer_unix-milli_nullable operation. +// TestRequestRequiredIntegerInt64Nullable invokes test_request_required_integer_int64_nullable operation. // -// POST /test_request_required_integer_unix-milli_nullable -func (c *Client) TestRequestRequiredIntegerUnixMilliNullable(ctx context.Context, request NilUnixMilli) (res Error, err error) { +// POST /test_request_required_integer_int64_nullable +func (c *Client) TestRequestRequiredIntegerInt64Nullable(ctx context.Context, request NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_nullable"), + otelogen.OperationID("test_request_required_integer_int64_nullable"), } // Validate request before sending. @@ -11326,7 +11371,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullable(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11343,14 +11388,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullable(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-milli_nullable" + u.Path += "/test_request_required_integer_int64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMilliNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11362,7 +11407,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullable(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMilliNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11370,12 +11415,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullable(ctx context.Context return result, nil } -// TestRequestRequiredIntegerUnixMilliNullableArray invokes test_request_required_integer_unix-milli_nullable_array operation. +// TestRequestRequiredIntegerInt64NullableArray invokes test_request_required_integer_int64_nullable_array operation. // -// POST /test_request_required_integer_unix-milli_nullable_array -func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArray(ctx context.Context, request []NilUnixMilli) (res Error, err error) { +// POST /test_request_required_integer_int64_nullable_array +func (c *Client) TestRequestRequiredIntegerInt64NullableArray(ctx context.Context, request []NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array"), + otelogen.OperationID("test_request_required_integer_int64_nullable_array"), } // Validate request before sending. if err := func() error { @@ -11398,7 +11443,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11415,14 +11460,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-milli_nullable_array" + u.Path += "/test_request_required_integer_int64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11434,7 +11479,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11442,12 +11487,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArray(ctx context.Co return result, nil } -// TestRequestRequiredIntegerUnixMilliNullableArrayArray invokes test_request_required_integer_unix-milli_nullable_array_array operation. +// TestRequestRequiredIntegerInt64NullableArrayArray invokes test_request_required_integer_int64_nullable_array_array operation. // -// POST /test_request_required_integer_unix-milli_nullable_array_array -func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx context.Context, request [][]NilUnixMilli) (res Error, err error) { +// POST /test_request_required_integer_int64_nullable_array_array +func (c *Client) TestRequestRequiredIntegerInt64NullableArrayArray(ctx context.Context, request [][]NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_int64_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -11487,7 +11532,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11504,14 +11549,14 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx conte stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-milli_nullable_array_array" + u.Path += "/test_request_required_integer_int64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11523,7 +11568,7 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx conte defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11531,12 +11576,12 @@ func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx conte return result, nil } -// TestRequestRequiredIntegerUnixNano invokes test_request_required_integer_unix-nano operation. +// TestRequestRequiredIntegerNullable invokes test_request_required_integer_nullable operation. // -// POST /test_request_required_integer_unix-nano -func (c *Client) TestRequestRequiredIntegerUnixNano(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_integer_nullable +func (c *Client) TestRequestRequiredIntegerNullable(ctx context.Context, request NilInt) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano"), + otelogen.OperationID("test_request_required_integer_nullable"), } // Validate request before sending. @@ -11551,7 +11596,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNano(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNano", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11568,14 +11613,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNano(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-nano" + u.Path += "/test_request_required_integer_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNanoRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11587,7 +11632,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNano(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNanoResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11595,12 +11640,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNano(ctx context.Context, request return result, nil } -// TestRequestRequiredIntegerUnixNanoArray invokes test_request_required_integer_unix-nano_array operation. +// TestRequestRequiredIntegerNullableArray invokes test_request_required_integer_nullable_array operation. // -// POST /test_request_required_integer_unix-nano_array -func (c *Client) TestRequestRequiredIntegerUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_integer_nullable_array +func (c *Client) TestRequestRequiredIntegerNullableArray(ctx context.Context, request []NilInt) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_array"), + otelogen.OperationID("test_request_required_integer_nullable_array"), } // Validate request before sending. if err := func() error { @@ -11623,7 +11668,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11640,14 +11685,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-nano_array" + u.Path += "/test_request_required_integer_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNanoArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11659,7 +11704,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNanoArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11667,12 +11712,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArray(ctx context.Context, re return result, nil } -// TestRequestRequiredIntegerUnixNanoArrayArray invokes test_request_required_integer_unix-nano_array_array operation. +// TestRequestRequiredIntegerNullableArrayArray invokes test_request_required_integer_nullable_array_array operation. // -// POST /test_request_required_integer_unix-nano_array_array -func (c *Client) TestRequestRequiredIntegerUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_integer_nullable_array_array +func (c *Client) TestRequestRequiredIntegerNullableArrayArray(ctx context.Context, request [][]NilInt) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_array_array"), + otelogen.OperationID("test_request_required_integer_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -11712,7 +11757,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11729,14 +11774,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-nano_array_array" + u.Path += "/test_request_required_integer_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11748,7 +11793,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11756,12 +11801,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoArrayArray(ctx context.Contex return result, nil } -// TestRequestRequiredIntegerUnixNanoNullable invokes test_request_required_integer_unix-nano_nullable operation. +// TestRequestRequiredIntegerUint invokes test_request_required_integer_uint operation. // -// POST /test_request_required_integer_unix-nano_nullable -func (c *Client) TestRequestRequiredIntegerUnixNanoNullable(ctx context.Context, request NilUnixNano) (res Error, err error) { +// POST /test_request_required_integer_uint +func (c *Client) TestRequestRequiredIntegerUint(ctx context.Context, request uint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_nullable"), + otelogen.OperationID("test_request_required_integer_uint"), } // Validate request before sending. @@ -11776,7 +11821,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11793,14 +11838,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-nano_nullable" + u.Path += "/test_request_required_integer_uint" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNanoNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUintRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11812,7 +11857,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNanoNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUintResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11820,12 +11865,76 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullable(ctx context.Context, return result, nil } -// TestRequestRequiredIntegerUnixNanoNullableArray invokes test_request_required_integer_unix-nano_nullable_array operation. +// TestRequestRequiredIntegerUint32 invokes test_request_required_integer_uint32 operation. // -// POST /test_request_required_integer_unix-nano_nullable_array -func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArray(ctx context.Context, request []NilUnixNano) (res Error, err error) { +// POST /test_request_required_integer_uint32 +func (c *Client) TestRequestRequiredIntegerUint32(ctx context.Context, request uint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array"), + otelogen.OperationID("test_request_required_integer_uint32"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint32", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_required_integer_uint32" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredIntegerUint32Request(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestRequiredIntegerUint32Response(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredIntegerUint32Array invokes test_request_required_integer_uint32_array operation. +// +// POST /test_request_required_integer_uint32_array +func (c *Client) TestRequestRequiredIntegerUint32Array(ctx context.Context, request []uint32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_integer_uint32_array"), } // Validate request before sending. if err := func() error { @@ -11848,7 +11957,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11865,14 +11974,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-nano_nullable_array" + u.Path += "/test_request_required_integer_uint32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11884,7 +11993,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11892,12 +12001,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArray(ctx context.Con return result, nil } -// TestRequestRequiredIntegerUnixNanoNullableArrayArray invokes test_request_required_integer_unix-nano_nullable_array_array operation. +// TestRequestRequiredIntegerUint32ArrayArray invokes test_request_required_integer_uint32_array_array operation. // -// POST /test_request_required_integer_unix-nano_nullable_array_array -func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx context.Context, request [][]NilUnixNano) (res Error, err error) { +// POST /test_request_required_integer_uint32_array_array +func (c *Client) TestRequestRequiredIntegerUint32ArrayArray(ctx context.Context, request [][]uint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_uint32_array_array"), } // Validate request before sending. if err := func() error { @@ -11937,7 +12046,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -11954,14 +12063,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-nano_nullable_array_array" + u.Path += "/test_request_required_integer_uint32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -11973,7 +12082,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11981,12 +12090,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx contex return result, nil } -// TestRequestRequiredIntegerUnixNullable invokes test_request_required_integer_unix_nullable operation. +// TestRequestRequiredIntegerUint32Nullable invokes test_request_required_integer_uint32_nullable operation. // -// POST /test_request_required_integer_unix_nullable -func (c *Client) TestRequestRequiredIntegerUnixNullable(ctx context.Context, request NilUnixSeconds) (res Error, err error) { +// POST /test_request_required_integer_uint32_nullable +func (c *Client) TestRequestRequiredIntegerUint32Nullable(ctx context.Context, request NilUint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_nullable"), + otelogen.OperationID("test_request_required_integer_uint32_nullable"), } // Validate request before sending. @@ -12001,7 +12110,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNullable(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12018,14 +12127,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNullable(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix_nullable" + u.Path += "/test_request_required_integer_uint32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12037,7 +12146,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNullable(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12045,12 +12154,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNullable(ctx context.Context, req return result, nil } -// TestRequestRequiredIntegerUnixNullableArray invokes test_request_required_integer_unix_nullable_array operation. +// TestRequestRequiredIntegerUint32NullableArray invokes test_request_required_integer_uint32_nullable_array operation. // -// POST /test_request_required_integer_unix_nullable_array -func (c *Client) TestRequestRequiredIntegerUnixNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { +// POST /test_request_required_integer_uint32_nullable_array +func (c *Client) TestRequestRequiredIntegerUint32NullableArray(ctx context.Context, request []NilUint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_nullable_array"), + otelogen.OperationID("test_request_required_integer_uint32_nullable_array"), } // Validate request before sending. if err := func() error { @@ -12073,7 +12182,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12090,14 +12199,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix_nullable_array" + u.Path += "/test_request_required_integer_uint32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12109,7 +12218,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12117,12 +12226,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArray(ctx context.Context return result, nil } -// TestRequestRequiredIntegerUnixNullableArrayArray invokes test_request_required_integer_unix_nullable_array_array operation. +// TestRequestRequiredIntegerUint32NullableArrayArray invokes test_request_required_integer_uint32_nullable_array_array operation. // -// POST /test_request_required_integer_unix_nullable_array_array -func (c *Client) TestRequestRequiredIntegerUnixNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { +// POST /test_request_required_integer_uint32_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUint32NullableArrayArray(ctx context.Context, request [][]NilUint32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_uint32_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -12162,7 +12271,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArrayArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12179,14 +12288,14 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArrayArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix_nullable_array_array" + u.Path += "/test_request_required_integer_uint32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12198,7 +12307,7 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArrayArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12206,12 +12315,12 @@ func (c *Client) TestRequestRequiredIntegerUnixNullableArrayArray(ctx context.Co return result, nil } -// TestRequestRequiredIntegerUnixSeconds invokes test_request_required_integer_unix-seconds operation. +// TestRequestRequiredIntegerUint64 invokes test_request_required_integer_uint64 operation. // -// POST /test_request_required_integer_unix-seconds -func (c *Client) TestRequestRequiredIntegerUnixSeconds(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_integer_uint64 +func (c *Client) TestRequestRequiredIntegerUint64(ctx context.Context, request uint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds"), + otelogen.OperationID("test_request_required_integer_uint64"), } // Validate request before sending. @@ -12226,7 +12335,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSeconds(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSeconds", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12243,14 +12352,14 @@ func (c *Client) TestRequestRequiredIntegerUnixSeconds(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-seconds" + u.Path += "/test_request_required_integer_uint64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixSecondsRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12262,7 +12371,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSeconds(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixSecondsResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12270,12 +12379,12 @@ func (c *Client) TestRequestRequiredIntegerUnixSeconds(ctx context.Context, requ return result, nil } -// TestRequestRequiredIntegerUnixSecondsArray invokes test_request_required_integer_unix-seconds_array operation. +// TestRequestRequiredIntegerUint64Array invokes test_request_required_integer_uint64_array operation. // -// POST /test_request_required_integer_unix-seconds_array -func (c *Client) TestRequestRequiredIntegerUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_integer_uint64_array +func (c *Client) TestRequestRequiredIntegerUint64Array(ctx context.Context, request []uint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_array"), + otelogen.OperationID("test_request_required_integer_uint64_array"), } // Validate request before sending. if err := func() error { @@ -12298,7 +12407,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12315,14 +12424,14 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-seconds_array" + u.Path += "/test_request_required_integer_uint64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixSecondsArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12334,7 +12443,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixSecondsArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12342,12 +12451,12 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArray(ctx context.Context, return result, nil } -// TestRequestRequiredIntegerUnixSecondsArrayArray invokes test_request_required_integer_unix-seconds_array_array operation. +// TestRequestRequiredIntegerUint64ArrayArray invokes test_request_required_integer_uint64_array_array operation. // -// POST /test_request_required_integer_unix-seconds_array_array -func (c *Client) TestRequestRequiredIntegerUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_integer_uint64_array_array +func (c *Client) TestRequestRequiredIntegerUint64ArrayArray(ctx context.Context, request [][]uint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_array_array"), + otelogen.OperationID("test_request_required_integer_uint64_array_array"), } // Validate request before sending. if err := func() error { @@ -12387,7 +12496,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12404,14 +12513,14 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-seconds_array_array" + u.Path += "/test_request_required_integer_uint64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12423,7 +12532,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12431,12 +12540,12 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredIntegerUnixSecondsNullable invokes test_request_required_integer_unix-seconds_nullable operation. +// TestRequestRequiredIntegerUint64Nullable invokes test_request_required_integer_uint64_nullable operation. // -// POST /test_request_required_integer_unix-seconds_nullable -func (c *Client) TestRequestRequiredIntegerUnixSecondsNullable(ctx context.Context, request NilUnixSeconds) (res Error, err error) { +// POST /test_request_required_integer_uint64_nullable +func (c *Client) TestRequestRequiredIntegerUint64Nullable(ctx context.Context, request NilUint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_nullable"), + otelogen.OperationID("test_request_required_integer_uint64_nullable"), } // Validate request before sending. @@ -12451,7 +12560,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullable(ctx context.Conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12468,14 +12577,14 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullable(ctx context.Conte stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-seconds_nullable" + u.Path += "/test_request_required_integer_uint64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixSecondsNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12487,7 +12596,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullable(ctx context.Conte defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixSecondsNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12495,12 +12604,12 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullable(ctx context.Conte return result, nil } -// TestRequestRequiredIntegerUnixSecondsNullableArray invokes test_request_required_integer_unix-seconds_nullable_array operation. +// TestRequestRequiredIntegerUint64NullableArray invokes test_request_required_integer_uint64_nullable_array operation. // -// POST /test_request_required_integer_unix-seconds_nullable_array -func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { +// POST /test_request_required_integer_uint64_nullable_array +func (c *Client) TestRequestRequiredIntegerUint64NullableArray(ctx context.Context, request []NilUint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_required_integer_uint64_nullable_array"), } // Validate request before sending. if err := func() error { @@ -12523,7 +12632,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArray(ctx context. c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12540,14 +12649,14 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArray(ctx context. stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-seconds_nullable_array" + u.Path += "/test_request_required_integer_uint64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12559,7 +12668,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArray(ctx context. defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12567,12 +12676,12 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArray(ctx context. return result, nil } -// TestRequestRequiredIntegerUnixSecondsNullableArrayArray invokes test_request_required_integer_unix-seconds_nullable_array_array operation. +// TestRequestRequiredIntegerUint64NullableArrayArray invokes test_request_required_integer_uint64_nullable_array_array operation. // -// POST /test_request_required_integer_unix-seconds_nullable_array_array -func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { +// POST /test_request_required_integer_uint64_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUint64NullableArrayArray(ctx context.Context, request [][]NilUint64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_uint64_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -12612,71 +12721,7 @@ func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArrayArray(ctx con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindClient), - ) - // Track stage for error reporting. - var stage string - defer func() { - if err != nil { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - c.errors.Add(ctx, 1, otelAttrs...) - } - span.End() - }() - - stage = "BuildURL" - u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_integer_unix-seconds_nullable_array_array" - - stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "POST", u, nil) - if err != nil { - return res, errors.Wrap(err, "create request") - } - if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") - } - - stage = "SendRequest" - resp, err := c.cfg.Client.Do(r) - if err != nil { - return res, errors.Wrap(err, "do request") - } - defer resp.Body.Close() - - stage = "DecodeResponse" - result, err := decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(resp, span) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// TestRequestRequiredNull invokes test_request_required_null operation. -// -// POST /test_request_required_null -func (c *Client) TestRequestRequiredNull(ctx context.Context, request struct{}) (res Error, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null"), - } - // Validate request before sending. - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - c.requests.Add(ctx, 1, otelAttrs...) - - // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNull", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12693,14 +12738,14 @@ func (c *Client) TestRequestRequiredNull(ctx context.Context, request struct{}) stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_null" + u.Path += "/test_request_required_integer_uint64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNullRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUint64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12712,7 +12757,7 @@ func (c *Client) TestRequestRequiredNull(ctx context.Context, request struct{}) defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNullResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUint64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12720,12 +12765,12 @@ func (c *Client) TestRequestRequiredNull(ctx context.Context, request struct{}) return result, nil } -// TestRequestRequiredNullArray invokes test_request_required_null_array operation. +// TestRequestRequiredIntegerUintArray invokes test_request_required_integer_uint_array operation. // -// POST /test_request_required_null_array -func (c *Client) TestRequestRequiredNullArray(ctx context.Context, request []struct{}) (res Error, err error) { +// POST /test_request_required_integer_uint_array +func (c *Client) TestRequestRequiredIntegerUintArray(ctx context.Context, request []uint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_array"), + otelogen.OperationID("test_request_required_integer_uint_array"), } // Validate request before sending. if err := func() error { @@ -12748,7 +12793,7 @@ func (c *Client) TestRequestRequiredNullArray(ctx context.Context, request []str c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUintArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12765,14 +12810,14 @@ func (c *Client) TestRequestRequiredNullArray(ctx context.Context, request []str stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_null_array" + u.Path += "/test_request_required_integer_uint_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNullArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUintArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12784,7 +12829,7 @@ func (c *Client) TestRequestRequiredNullArray(ctx context.Context, request []str defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNullArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUintArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12792,12 +12837,12 @@ func (c *Client) TestRequestRequiredNullArray(ctx context.Context, request []str return result, nil } -// TestRequestRequiredNullArrayArray invokes test_request_required_null_array_array operation. +// TestRequestRequiredIntegerUintArrayArray invokes test_request_required_integer_uint_array_array operation. // -// POST /test_request_required_null_array_array -func (c *Client) TestRequestRequiredNullArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { +// POST /test_request_required_integer_uint_array_array +func (c *Client) TestRequestRequiredIntegerUintArrayArray(ctx context.Context, request [][]uint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_array_array"), + otelogen.OperationID("test_request_required_integer_uint_array_array"), } // Validate request before sending. if err := func() error { @@ -12837,7 +12882,7 @@ func (c *Client) TestRequestRequiredNullArrayArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUintArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12854,14 +12899,14 @@ func (c *Client) TestRequestRequiredNullArrayArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_null_array_array" + u.Path += "/test_request_required_integer_uint_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNullArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUintArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12873,7 +12918,7 @@ func (c *Client) TestRequestRequiredNullArrayArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNullArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUintArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12881,12 +12926,12 @@ func (c *Client) TestRequestRequiredNullArrayArray(ctx context.Context, request return result, nil } -// TestRequestRequiredNullNullable invokes test_request_required_null_nullable operation. +// TestRequestRequiredIntegerUintNullable invokes test_request_required_integer_uint_nullable operation. // -// POST /test_request_required_null_nullable -func (c *Client) TestRequestRequiredNullNullable(ctx context.Context, request struct{}) (res Error, err error) { +// POST /test_request_required_integer_uint_nullable +func (c *Client) TestRequestRequiredIntegerUintNullable(ctx context.Context, request NilUint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_nullable"), + otelogen.OperationID("test_request_required_integer_uint_nullable"), } // Validate request before sending. @@ -12901,7 +12946,7 @@ func (c *Client) TestRequestRequiredNullNullable(ctx context.Context, request st c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUintNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12918,14 +12963,14 @@ func (c *Client) TestRequestRequiredNullNullable(ctx context.Context, request st stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_null_nullable" + u.Path += "/test_request_required_integer_uint_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNullNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUintNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -12937,7 +12982,7 @@ func (c *Client) TestRequestRequiredNullNullable(ctx context.Context, request st defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNullNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUintNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -12945,12 +12990,12 @@ func (c *Client) TestRequestRequiredNullNullable(ctx context.Context, request st return result, nil } -// TestRequestRequiredNullNullableArray invokes test_request_required_null_nullable_array operation. +// TestRequestRequiredIntegerUintNullableArray invokes test_request_required_integer_uint_nullable_array operation. // -// POST /test_request_required_null_nullable_array -func (c *Client) TestRequestRequiredNullNullableArray(ctx context.Context, request []struct{}) (res Error, err error) { +// POST /test_request_required_integer_uint_nullable_array +func (c *Client) TestRequestRequiredIntegerUintNullableArray(ctx context.Context, request []NilUint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_nullable_array"), + otelogen.OperationID("test_request_required_integer_uint_nullable_array"), } // Validate request before sending. if err := func() error { @@ -12973,7 +13018,7 @@ func (c *Client) TestRequestRequiredNullNullableArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUintNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -12990,14 +13035,14 @@ func (c *Client) TestRequestRequiredNullNullableArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_null_nullable_array" + u.Path += "/test_request_required_integer_uint_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNullNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUintNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13009,7 +13054,7 @@ func (c *Client) TestRequestRequiredNullNullableArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNullNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUintNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13017,12 +13062,12 @@ func (c *Client) TestRequestRequiredNullNullableArray(ctx context.Context, reque return result, nil } -// TestRequestRequiredNullNullableArrayArray invokes test_request_required_null_nullable_array_array operation. +// TestRequestRequiredIntegerUintNullableArrayArray invokes test_request_required_integer_uint_nullable_array_array operation. // -// POST /test_request_required_null_nullable_array_array -func (c *Client) TestRequestRequiredNullNullableArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { +// POST /test_request_required_integer_uint_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUintNullableArrayArray(ctx context.Context, request [][]NilUint) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_uint_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -13062,7 +13107,7 @@ func (c *Client) TestRequestRequiredNullNullableArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUintNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13079,14 +13124,14 @@ func (c *Client) TestRequestRequiredNullNullableArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_null_nullable_array_array" + u.Path += "/test_request_required_integer_uint_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNullNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUintNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13098,7 +13143,7 @@ func (c *Client) TestRequestRequiredNullNullableArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNullNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUintNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13106,22 +13151,14 @@ func (c *Client) TestRequestRequiredNullNullableArrayArray(ctx context.Context, return result, nil } -// TestRequestRequiredNumber invokes test_request_required_number operation. +// TestRequestRequiredIntegerUnix invokes test_request_required_integer_unix operation. // -// POST /test_request_required_number -func (c *Client) TestRequestRequiredNumber(ctx context.Context, request float64) (res Error, err error) { +// POST /test_request_required_integer_unix +func (c *Client) TestRequestRequiredIntegerUnix(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number"), + otelogen.OperationID("test_request_required_integer_unix"), } // Validate request before sending. - if err := func() error { - if err := (validate.Float{}).Validate(float64(request)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -13134,7 +13171,7 @@ func (c *Client) TestRequestRequiredNumber(ctx context.Context, request float64) c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumber", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnix", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13151,14 +13188,14 @@ func (c *Client) TestRequestRequiredNumber(ctx context.Context, request float64) stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number" + u.Path += "/test_request_required_integer_unix" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13170,7 +13207,7 @@ func (c *Client) TestRequestRequiredNumber(ctx context.Context, request float64) defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13178,35 +13215,18 @@ func (c *Client) TestRequestRequiredNumber(ctx context.Context, request float64) return result, nil } -// TestRequestRequiredNumberArray invokes test_request_required_number_array operation. +// TestRequestRequiredIntegerUnixArray invokes test_request_required_integer_unix_array operation. // -// POST /test_request_required_number_array -func (c *Client) TestRequestRequiredNumberArray(ctx context.Context, request []float64) (res Error, err error) { +// POST /test_request_required_integer_unix_array +func (c *Client) TestRequestRequiredIntegerUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_array"), + otelogen.OperationID("test_request_required_integer_unix_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -13223,7 +13243,7 @@ func (c *Client) TestRequestRequiredNumberArray(ctx context.Context, request []f c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13240,14 +13260,14 @@ func (c *Client) TestRequestRequiredNumberArray(ctx context.Context, request []f stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_array" + u.Path += "/test_request_required_integer_unix_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13259,7 +13279,7 @@ func (c *Client) TestRequestRequiredNumberArray(ctx context.Context, request []f defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13267,12 +13287,12 @@ func (c *Client) TestRequestRequiredNumberArray(ctx context.Context, request []f return result, nil } -// TestRequestRequiredNumberArrayArray invokes test_request_required_number_array_array operation. +// TestRequestRequiredIntegerUnixArrayArray invokes test_request_required_integer_unix_array_array operation. // -// POST /test_request_required_number_array_array -func (c *Client) TestRequestRequiredNumberArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { +// POST /test_request_required_integer_unix_array_array +func (c *Client) TestRequestRequiredIntegerUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_array_array"), + otelogen.OperationID("test_request_required_integer_unix_array_array"), } // Validate request before sending. if err := func() error { @@ -13285,23 +13305,6 @@ func (c *Client) TestRequestRequiredNumberArrayArray(ctx context.Context, reques if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -13329,7 +13332,7 @@ func (c *Client) TestRequestRequiredNumberArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13346,14 +13349,14 @@ func (c *Client) TestRequestRequiredNumberArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_array_array" + u.Path += "/test_request_required_integer_unix_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13365,7 +13368,7 @@ func (c *Client) TestRequestRequiredNumberArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13373,22 +13376,14 @@ func (c *Client) TestRequestRequiredNumberArrayArray(ctx context.Context, reques return result, nil } -// TestRequestRequiredNumberDouble invokes test_request_required_number_double operation. +// TestRequestRequiredIntegerUnixMicro invokes test_request_required_integer_unix-micro operation. // -// POST /test_request_required_number_double -func (c *Client) TestRequestRequiredNumberDouble(ctx context.Context, request float64) (res Error, err error) { +// POST /test_request_required_integer_unix-micro +func (c *Client) TestRequestRequiredIntegerUnixMicro(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double"), + otelogen.OperationID("test_request_required_integer_unix-micro"), } // Validate request before sending. - if err := func() error { - if err := (validate.Float{}).Validate(float64(request)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -13401,7 +13396,7 @@ func (c *Client) TestRequestRequiredNumberDouble(ctx context.Context, request fl c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDouble", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicro", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13418,14 +13413,14 @@ func (c *Client) TestRequestRequiredNumberDouble(ctx context.Context, request fl stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_double" + u.Path += "/test_request_required_integer_unix-micro" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberDoubleRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13437,7 +13432,7 @@ func (c *Client) TestRequestRequiredNumberDouble(ctx context.Context, request fl defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberDoubleResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMicroResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13445,35 +13440,18 @@ func (c *Client) TestRequestRequiredNumberDouble(ctx context.Context, request fl return result, nil } -// TestRequestRequiredNumberDoubleArray invokes test_request_required_number_double_array operation. +// TestRequestRequiredIntegerUnixMicroArray invokes test_request_required_integer_unix-micro_array operation. // -// POST /test_request_required_number_double_array -func (c *Client) TestRequestRequiredNumberDoubleArray(ctx context.Context, request []float64) (res Error, err error) { +// POST /test_request_required_integer_unix-micro_array +func (c *Client) TestRequestRequiredIntegerUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -13490,7 +13468,7 @@ func (c *Client) TestRequestRequiredNumberDoubleArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13507,14 +13485,14 @@ func (c *Client) TestRequestRequiredNumberDoubleArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_double_array" + u.Path += "/test_request_required_integer_unix-micro_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberDoubleArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13526,7 +13504,7 @@ func (c *Client) TestRequestRequiredNumberDoubleArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberDoubleArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMicroArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13534,12 +13512,12 @@ func (c *Client) TestRequestRequiredNumberDoubleArray(ctx context.Context, reque return result, nil } -// TestRequestRequiredNumberDoubleArrayArray invokes test_request_required_number_double_array_array operation. +// TestRequestRequiredIntegerUnixMicroArrayArray invokes test_request_required_integer_unix-micro_array_array operation. // -// POST /test_request_required_number_double_array_array -func (c *Client) TestRequestRequiredNumberDoubleArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { +// POST /test_request_required_integer_unix-micro_array_array +func (c *Client) TestRequestRequiredIntegerUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_array_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_array_array"), } // Validate request before sending. if err := func() error { @@ -13552,23 +13530,6 @@ func (c *Client) TestRequestRequiredNumberDoubleArrayArray(ctx context.Context, if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -13596,7 +13557,7 @@ func (c *Client) TestRequestRequiredNumberDoubleArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13613,14 +13574,14 @@ func (c *Client) TestRequestRequiredNumberDoubleArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_double_array_array" + u.Path += "/test_request_required_integer_unix-micro_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberDoubleArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13632,7 +13593,7 @@ func (c *Client) TestRequestRequiredNumberDoubleArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberDoubleArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13640,22 +13601,14 @@ func (c *Client) TestRequestRequiredNumberDoubleArrayArray(ctx context.Context, return result, nil } -// TestRequestRequiredNumberDoubleNullable invokes test_request_required_number_double_nullable operation. +// TestRequestRequiredIntegerUnixMicroNullable invokes test_request_required_integer_unix-micro_nullable operation. // -// POST /test_request_required_number_double_nullable -func (c *Client) TestRequestRequiredNumberDoubleNullable(ctx context.Context, request NilFloat64) (res Error, err error) { +// POST /test_request_required_integer_unix-micro_nullable +func (c *Client) TestRequestRequiredIntegerUnixMicroNullable(ctx context.Context, request NilUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_nullable"), + otelogen.OperationID("test_request_required_integer_unix-micro_nullable"), } // Validate request before sending. - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -13668,7 +13621,7 @@ func (c *Client) TestRequestRequiredNumberDoubleNullable(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13685,14 +13638,14 @@ func (c *Client) TestRequestRequiredNumberDoubleNullable(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_double_nullable" + u.Path += "/test_request_required_integer_unix-micro_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberDoubleNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13704,7 +13657,7 @@ func (c *Client) TestRequestRequiredNumberDoubleNullable(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberDoubleNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMicroNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13712,35 +13665,18 @@ func (c *Client) TestRequestRequiredNumberDoubleNullable(ctx context.Context, re return result, nil } -// TestRequestRequiredNumberDoubleNullableArray invokes test_request_required_number_double_nullable_array operation. +// TestRequestRequiredIntegerUnixMicroNullableArray invokes test_request_required_integer_unix-micro_nullable_array operation. // -// POST /test_request_required_number_double_nullable_array -func (c *Client) TestRequestRequiredNumberDoubleNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { +// POST /test_request_required_integer_unix-micro_nullable_array +func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArray(ctx context.Context, request []NilUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -13757,7 +13693,7 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13774,14 +13710,14 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_double_nullable_array" + u.Path += "/test_request_required_integer_unix-micro_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberDoubleNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13793,7 +13729,7 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberDoubleNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13801,12 +13737,12 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArray(ctx context.Contex return result, nil } -// TestRequestRequiredNumberDoubleNullableArrayArray invokes test_request_required_number_double_nullable_array_array operation. +// TestRequestRequiredIntegerUnixMicroNullableArrayArray invokes test_request_required_integer_unix-micro_nullable_array_array operation. // -// POST /test_request_required_number_double_nullable_array_array -func (c *Client) TestRequestRequiredNumberDoubleNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { +// POST /test_request_required_integer_unix-micro_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx context.Context, request [][]NilUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -13819,23 +13755,6 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArrayArray(ctx context.C if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -13863,7 +13782,7 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArrayArray(ctx context.C c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13880,14 +13799,14 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArrayArray(ctx context.C stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_double_nullable_array_array" + u.Path += "/test_request_required_integer_unix-micro_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13899,7 +13818,7 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArrayArray(ctx context.C defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13907,22 +13826,14 @@ func (c *Client) TestRequestRequiredNumberDoubleNullableArrayArray(ctx context.C return result, nil } -// TestRequestRequiredNumberFloat invokes test_request_required_number_float operation. +// TestRequestRequiredIntegerUnixMilli invokes test_request_required_integer_unix-milli operation. // -// POST /test_request_required_number_float -func (c *Client) TestRequestRequiredNumberFloat(ctx context.Context, request float32) (res Error, err error) { +// POST /test_request_required_integer_unix-milli +func (c *Client) TestRequestRequiredIntegerUnixMilli(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float"), + otelogen.OperationID("test_request_required_integer_unix-milli"), } // Validate request before sending. - if err := func() error { - if err := (validate.Float{}).Validate(float64(request)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -13935,7 +13846,7 @@ func (c *Client) TestRequestRequiredNumberFloat(ctx context.Context, request flo c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloat", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilli", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -13952,14 +13863,14 @@ func (c *Client) TestRequestRequiredNumberFloat(ctx context.Context, request flo stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_float" + u.Path += "/test_request_required_integer_unix-milli" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberFloatRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -13971,7 +13882,7 @@ func (c *Client) TestRequestRequiredNumberFloat(ctx context.Context, request flo defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberFloatResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMilliResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -13979,35 +13890,18 @@ func (c *Client) TestRequestRequiredNumberFloat(ctx context.Context, request flo return result, nil } -// TestRequestRequiredNumberFloatArray invokes test_request_required_number_float_array operation. +// TestRequestRequiredIntegerUnixMilliArray invokes test_request_required_integer_unix-milli_array operation. // -// POST /test_request_required_number_float_array -func (c *Client) TestRequestRequiredNumberFloatArray(ctx context.Context, request []float32) (res Error, err error) { +// POST /test_request_required_integer_unix-milli_array +func (c *Client) TestRequestRequiredIntegerUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -14024,7 +13918,7 @@ func (c *Client) TestRequestRequiredNumberFloatArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14041,14 +13935,14 @@ func (c *Client) TestRequestRequiredNumberFloatArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_float_array" + u.Path += "/test_request_required_integer_unix-milli_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberFloatArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14060,7 +13954,7 @@ func (c *Client) TestRequestRequiredNumberFloatArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberFloatArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMilliArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14068,12 +13962,12 @@ func (c *Client) TestRequestRequiredNumberFloatArray(ctx context.Context, reques return result, nil } -// TestRequestRequiredNumberFloatArrayArray invokes test_request_required_number_float_array_array operation. +// TestRequestRequiredIntegerUnixMilliArrayArray invokes test_request_required_integer_unix-milli_array_array operation. // -// POST /test_request_required_number_float_array_array -func (c *Client) TestRequestRequiredNumberFloatArrayArray(ctx context.Context, request [][]float32) (res Error, err error) { +// POST /test_request_required_integer_unix-milli_array_array +func (c *Client) TestRequestRequiredIntegerUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_array_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_array_array"), } // Validate request before sending. if err := func() error { @@ -14086,23 +13980,6 @@ func (c *Client) TestRequestRequiredNumberFloatArrayArray(ctx context.Context, r if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -14130,7 +14007,7 @@ func (c *Client) TestRequestRequiredNumberFloatArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14147,14 +14024,14 @@ func (c *Client) TestRequestRequiredNumberFloatArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_float_array_array" + u.Path += "/test_request_required_integer_unix-milli_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberFloatArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14166,7 +14043,7 @@ func (c *Client) TestRequestRequiredNumberFloatArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberFloatArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14174,22 +14051,14 @@ func (c *Client) TestRequestRequiredNumberFloatArrayArray(ctx context.Context, r return result, nil } -// TestRequestRequiredNumberFloatNullable invokes test_request_required_number_float_nullable operation. +// TestRequestRequiredIntegerUnixMilliNullable invokes test_request_required_integer_unix-milli_nullable operation. // -// POST /test_request_required_number_float_nullable -func (c *Client) TestRequestRequiredNumberFloatNullable(ctx context.Context, request NilFloat32) (res Error, err error) { +// POST /test_request_required_integer_unix-milli_nullable +func (c *Client) TestRequestRequiredIntegerUnixMilliNullable(ctx context.Context, request NilUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_nullable"), + otelogen.OperationID("test_request_required_integer_unix-milli_nullable"), } // Validate request before sending. - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -14202,7 +14071,7 @@ func (c *Client) TestRequestRequiredNumberFloatNullable(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14219,14 +14088,14 @@ func (c *Client) TestRequestRequiredNumberFloatNullable(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_float_nullable" + u.Path += "/test_request_required_integer_unix-milli_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberFloatNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14238,7 +14107,7 @@ func (c *Client) TestRequestRequiredNumberFloatNullable(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberFloatNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMilliNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14246,35 +14115,18 @@ func (c *Client) TestRequestRequiredNumberFloatNullable(ctx context.Context, req return result, nil } -// TestRequestRequiredNumberFloatNullableArray invokes test_request_required_number_float_nullable_array operation. +// TestRequestRequiredIntegerUnixMilliNullableArray invokes test_request_required_integer_unix-milli_nullable_array operation. // -// POST /test_request_required_number_float_nullable_array -func (c *Client) TestRequestRequiredNumberFloatNullableArray(ctx context.Context, request []NilFloat32) (res Error, err error) { +// POST /test_request_required_integer_unix-milli_nullable_array +func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArray(ctx context.Context, request []NilUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -14291,7 +14143,7 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14308,14 +14160,14 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_float_nullable_array" + u.Path += "/test_request_required_integer_unix-milli_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberFloatNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14327,7 +14179,7 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberFloatNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14335,12 +14187,12 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArray(ctx context.Context return result, nil } -// TestRequestRequiredNumberFloatNullableArrayArray invokes test_request_required_number_float_nullable_array_array operation. +// TestRequestRequiredIntegerUnixMilliNullableArrayArray invokes test_request_required_integer_unix-milli_nullable_array_array operation. // -// POST /test_request_required_number_float_nullable_array_array -func (c *Client) TestRequestRequiredNumberFloatNullableArrayArray(ctx context.Context, request [][]NilFloat32) (res Error, err error) { +// POST /test_request_required_integer_unix-milli_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx context.Context, request [][]NilUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -14353,23 +14205,6 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArrayArray(ctx context.Co if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -14397,7 +14232,7 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArrayArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14414,14 +14249,14 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArrayArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_float_nullable_array_array" + u.Path += "/test_request_required_integer_unix-milli_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14433,7 +14268,7 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArrayArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14441,12 +14276,12 @@ func (c *Client) TestRequestRequiredNumberFloatNullableArrayArray(ctx context.Co return result, nil } -// TestRequestRequiredNumberInt32 invokes test_request_required_number_int32 operation. +// TestRequestRequiredIntegerUnixNano invokes test_request_required_integer_unix-nano operation. // -// POST /test_request_required_number_int32 -func (c *Client) TestRequestRequiredNumberInt32(ctx context.Context, request int32) (res Error, err error) { +// POST /test_request_required_integer_unix-nano +func (c *Client) TestRequestRequiredIntegerUnixNano(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32"), + otelogen.OperationID("test_request_required_integer_unix-nano"), } // Validate request before sending. @@ -14461,7 +14296,7 @@ func (c *Client) TestRequestRequiredNumberInt32(ctx context.Context, request int c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNano", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14478,14 +14313,14 @@ func (c *Client) TestRequestRequiredNumberInt32(ctx context.Context, request int stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int32" + u.Path += "/test_request_required_integer_unix-nano" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt32Request(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14497,7 +14332,7 @@ func (c *Client) TestRequestRequiredNumberInt32(ctx context.Context, request int defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt32Response(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNanoResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14505,12 +14340,12 @@ func (c *Client) TestRequestRequiredNumberInt32(ctx context.Context, request int return result, nil } -// TestRequestRequiredNumberInt32Array invokes test_request_required_number_int32_array operation. +// TestRequestRequiredIntegerUnixNanoArray invokes test_request_required_integer_unix-nano_array operation. // -// POST /test_request_required_number_int32_array -func (c *Client) TestRequestRequiredNumberInt32Array(ctx context.Context, request []int32) (res Error, err error) { +// POST /test_request_required_integer_unix-nano_array +func (c *Client) TestRequestRequiredIntegerUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_array"), } // Validate request before sending. if err := func() error { @@ -14533,7 +14368,7 @@ func (c *Client) TestRequestRequiredNumberInt32Array(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14550,14 +14385,14 @@ func (c *Client) TestRequestRequiredNumberInt32Array(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int32_array" + u.Path += "/test_request_required_integer_unix-nano_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt32ArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14569,7 +14404,7 @@ func (c *Client) TestRequestRequiredNumberInt32Array(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt32ArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNanoArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14577,12 +14412,12 @@ func (c *Client) TestRequestRequiredNumberInt32Array(ctx context.Context, reques return result, nil } -// TestRequestRequiredNumberInt32ArrayArray invokes test_request_required_number_int32_array_array operation. +// TestRequestRequiredIntegerUnixNanoArrayArray invokes test_request_required_integer_unix-nano_array_array operation. // -// POST /test_request_required_number_int32_array_array -func (c *Client) TestRequestRequiredNumberInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { +// POST /test_request_required_integer_unix-nano_array_array +func (c *Client) TestRequestRequiredIntegerUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_array_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_array_array"), } // Validate request before sending. if err := func() error { @@ -14622,7 +14457,7 @@ func (c *Client) TestRequestRequiredNumberInt32ArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14639,14 +14474,14 @@ func (c *Client) TestRequestRequiredNumberInt32ArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int32_array_array" + u.Path += "/test_request_required_integer_unix-nano_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt32ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14658,7 +14493,7 @@ func (c *Client) TestRequestRequiredNumberInt32ArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt32ArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14666,12 +14501,12 @@ func (c *Client) TestRequestRequiredNumberInt32ArrayArray(ctx context.Context, r return result, nil } -// TestRequestRequiredNumberInt32Nullable invokes test_request_required_number_int32_nullable operation. +// TestRequestRequiredIntegerUnixNanoNullable invokes test_request_required_integer_unix-nano_nullable operation. // -// POST /test_request_required_number_int32_nullable -func (c *Client) TestRequestRequiredNumberInt32Nullable(ctx context.Context, request NilInt32) (res Error, err error) { +// POST /test_request_required_integer_unix-nano_nullable +func (c *Client) TestRequestRequiredIntegerUnixNanoNullable(ctx context.Context, request NilUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_nullable"), + otelogen.OperationID("test_request_required_integer_unix-nano_nullable"), } // Validate request before sending. @@ -14686,7 +14521,7 @@ func (c *Client) TestRequestRequiredNumberInt32Nullable(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14703,14 +14538,14 @@ func (c *Client) TestRequestRequiredNumberInt32Nullable(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int32_nullable" + u.Path += "/test_request_required_integer_unix-nano_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt32NullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14722,7 +14557,7 @@ func (c *Client) TestRequestRequiredNumberInt32Nullable(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt32NullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNanoNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14730,12 +14565,12 @@ func (c *Client) TestRequestRequiredNumberInt32Nullable(ctx context.Context, req return result, nil } -// TestRequestRequiredNumberInt32NullableArray invokes test_request_required_number_int32_nullable_array operation. +// TestRequestRequiredIntegerUnixNanoNullableArray invokes test_request_required_integer_unix-nano_nullable_array operation. // -// POST /test_request_required_number_int32_nullable_array -func (c *Client) TestRequestRequiredNumberInt32NullableArray(ctx context.Context, request []NilInt32) (res Error, err error) { +// POST /test_request_required_integer_unix-nano_nullable_array +func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArray(ctx context.Context, request []NilUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array"), } // Validate request before sending. if err := func() error { @@ -14758,7 +14593,7 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14775,14 +14610,14 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int32_nullable_array" + u.Path += "/test_request_required_integer_unix-nano_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt32NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14794,7 +14629,7 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt32NullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14802,12 +14637,12 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArray(ctx context.Context return result, nil } -// TestRequestRequiredNumberInt32NullableArrayArray invokes test_request_required_number_int32_nullable_array_array operation. +// TestRequestRequiredIntegerUnixNanoNullableArrayArray invokes test_request_required_integer_unix-nano_nullable_array_array operation. // -// POST /test_request_required_number_int32_nullable_array_array -func (c *Client) TestRequestRequiredNumberInt32NullableArrayArray(ctx context.Context, request [][]NilInt32) (res Error, err error) { +// POST /test_request_required_integer_unix-nano_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx context.Context, request [][]NilUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -14847,7 +14682,7 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArrayArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14864,14 +14699,14 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArrayArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int32_nullable_array_array" + u.Path += "/test_request_required_integer_unix-nano_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14883,7 +14718,7 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArrayArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14891,12 +14726,12 @@ func (c *Client) TestRequestRequiredNumberInt32NullableArrayArray(ctx context.Co return result, nil } -// TestRequestRequiredNumberInt64 invokes test_request_required_number_int64 operation. +// TestRequestRequiredIntegerUnixNullable invokes test_request_required_integer_unix_nullable operation. // -// POST /test_request_required_number_int64 -func (c *Client) TestRequestRequiredNumberInt64(ctx context.Context, request int64) (res Error, err error) { +// POST /test_request_required_integer_unix_nullable +func (c *Client) TestRequestRequiredIntegerUnixNullable(ctx context.Context, request NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64"), + otelogen.OperationID("test_request_required_integer_unix_nullable"), } // Validate request before sending. @@ -14911,7 +14746,7 @@ func (c *Client) TestRequestRequiredNumberInt64(ctx context.Context, request int c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -14928,14 +14763,14 @@ func (c *Client) TestRequestRequiredNumberInt64(ctx context.Context, request int stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int64" + u.Path += "/test_request_required_integer_unix_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt64Request(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -14947,7 +14782,7 @@ func (c *Client) TestRequestRequiredNumberInt64(ctx context.Context, request int defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt64Response(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -14955,12 +14790,12 @@ func (c *Client) TestRequestRequiredNumberInt64(ctx context.Context, request int return result, nil } -// TestRequestRequiredNumberInt64Array invokes test_request_required_number_int64_array operation. +// TestRequestRequiredIntegerUnixNullableArray invokes test_request_required_integer_unix_nullable_array operation. // -// POST /test_request_required_number_int64_array -func (c *Client) TestRequestRequiredNumberInt64Array(ctx context.Context, request []int64) (res Error, err error) { +// POST /test_request_required_integer_unix_nullable_array +func (c *Client) TestRequestRequiredIntegerUnixNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_array"), + otelogen.OperationID("test_request_required_integer_unix_nullable_array"), } // Validate request before sending. if err := func() error { @@ -14983,7 +14818,7 @@ func (c *Client) TestRequestRequiredNumberInt64Array(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15000,14 +14835,14 @@ func (c *Client) TestRequestRequiredNumberInt64Array(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int64_array" + u.Path += "/test_request_required_integer_unix_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt64ArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15019,7 +14854,7 @@ func (c *Client) TestRequestRequiredNumberInt64Array(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt64ArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15027,12 +14862,12 @@ func (c *Client) TestRequestRequiredNumberInt64Array(ctx context.Context, reques return result, nil } -// TestRequestRequiredNumberInt64ArrayArray invokes test_request_required_number_int64_array_array operation. +// TestRequestRequiredIntegerUnixNullableArrayArray invokes test_request_required_integer_unix_nullable_array_array operation. // -// POST /test_request_required_number_int64_array_array -func (c *Client) TestRequestRequiredNumberInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { +// POST /test_request_required_integer_unix_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUnixNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_array_array"), + otelogen.OperationID("test_request_required_integer_unix_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -15072,7 +14907,7 @@ func (c *Client) TestRequestRequiredNumberInt64ArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15089,14 +14924,14 @@ func (c *Client) TestRequestRequiredNumberInt64ArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int64_array_array" + u.Path += "/test_request_required_integer_unix_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt64ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15108,7 +14943,7 @@ func (c *Client) TestRequestRequiredNumberInt64ArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt64ArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15116,12 +14951,12 @@ func (c *Client) TestRequestRequiredNumberInt64ArrayArray(ctx context.Context, r return result, nil } -// TestRequestRequiredNumberInt64Nullable invokes test_request_required_number_int64_nullable operation. +// TestRequestRequiredIntegerUnixSeconds invokes test_request_required_integer_unix-seconds operation. // -// POST /test_request_required_number_int64_nullable -func (c *Client) TestRequestRequiredNumberInt64Nullable(ctx context.Context, request NilInt64) (res Error, err error) { +// POST /test_request_required_integer_unix-seconds +func (c *Client) TestRequestRequiredIntegerUnixSeconds(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_nullable"), + otelogen.OperationID("test_request_required_integer_unix-seconds"), } // Validate request before sending. @@ -15136,7 +14971,7 @@ func (c *Client) TestRequestRequiredNumberInt64Nullable(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSeconds", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15153,14 +14988,14 @@ func (c *Client) TestRequestRequiredNumberInt64Nullable(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int64_nullable" + u.Path += "/test_request_required_integer_unix-seconds" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt64NullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15172,7 +15007,7 @@ func (c *Client) TestRequestRequiredNumberInt64Nullable(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt64NullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixSecondsResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15180,12 +15015,12 @@ func (c *Client) TestRequestRequiredNumberInt64Nullable(ctx context.Context, req return result, nil } -// TestRequestRequiredNumberInt64NullableArray invokes test_request_required_number_int64_nullable_array operation. +// TestRequestRequiredIntegerUnixSecondsArray invokes test_request_required_integer_unix-seconds_array operation. // -// POST /test_request_required_number_int64_nullable_array -func (c *Client) TestRequestRequiredNumberInt64NullableArray(ctx context.Context, request []NilInt64) (res Error, err error) { +// POST /test_request_required_integer_unix-seconds_array +func (c *Client) TestRequestRequiredIntegerUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_array"), } // Validate request before sending. if err := func() error { @@ -15208,7 +15043,7 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15225,14 +15060,14 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int64_nullable_array" + u.Path += "/test_request_required_integer_unix-seconds_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt64NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15244,7 +15079,7 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt64NullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixSecondsArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15252,12 +15087,12 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArray(ctx context.Context return result, nil } -// TestRequestRequiredNumberInt64NullableArrayArray invokes test_request_required_number_int64_nullable_array_array operation. +// TestRequestRequiredIntegerUnixSecondsArrayArray invokes test_request_required_integer_unix-seconds_array_array operation. // -// POST /test_request_required_number_int64_nullable_array_array -func (c *Client) TestRequestRequiredNumberInt64NullableArrayArray(ctx context.Context, request [][]NilInt64) (res Error, err error) { +// POST /test_request_required_integer_unix-seconds_array_array +func (c *Client) TestRequestRequiredIntegerUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_array_array"), } // Validate request before sending. if err := func() error { @@ -15297,7 +15132,7 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArrayArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15314,14 +15149,14 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArrayArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_int64_nullable_array_array" + u.Path += "/test_request_required_integer_unix-seconds_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15333,7 +15168,7 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArrayArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15341,22 +15176,14 @@ func (c *Client) TestRequestRequiredNumberInt64NullableArrayArray(ctx context.Co return result, nil } -// TestRequestRequiredNumberNullable invokes test_request_required_number_nullable operation. +// TestRequestRequiredIntegerUnixSecondsNullable invokes test_request_required_integer_unix-seconds_nullable operation. // -// POST /test_request_required_number_nullable -func (c *Client) TestRequestRequiredNumberNullable(ctx context.Context, request NilFloat64) (res Error, err error) { +// POST /test_request_required_integer_unix-seconds_nullable +func (c *Client) TestRequestRequiredIntegerUnixSecondsNullable(ctx context.Context, request NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_nullable"), + otelogen.OperationID("test_request_required_integer_unix-seconds_nullable"), } // Validate request before sending. - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -15369,7 +15196,7 @@ func (c *Client) TestRequestRequiredNumberNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15386,14 +15213,14 @@ func (c *Client) TestRequestRequiredNumberNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_nullable" + u.Path += "/test_request_required_integer_unix-seconds_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15405,7 +15232,7 @@ func (c *Client) TestRequestRequiredNumberNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberNullableResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixSecondsNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15413,35 +15240,18 @@ func (c *Client) TestRequestRequiredNumberNullable(ctx context.Context, request return result, nil } -// TestRequestRequiredNumberNullableArray invokes test_request_required_number_nullable_array operation. +// TestRequestRequiredIntegerUnixSecondsNullableArray invokes test_request_required_integer_unix-seconds_nullable_array operation. // -// POST /test_request_required_number_nullable_array -func (c *Client) TestRequestRequiredNumberNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { +// POST /test_request_required_integer_unix-seconds_nullable_array +func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArray(ctx context.Context, request []NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -15458,7 +15268,7 @@ func (c *Client) TestRequestRequiredNumberNullableArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15475,14 +15285,14 @@ func (c *Client) TestRequestRequiredNumberNullableArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_nullable_array" + u.Path += "/test_request_required_integer_unix-seconds_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15494,7 +15304,7 @@ func (c *Client) TestRequestRequiredNumberNullableArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15502,12 +15312,12 @@ func (c *Client) TestRequestRequiredNumberNullableArray(ctx context.Context, req return result, nil } -// TestRequestRequiredNumberNullableArrayArray invokes test_request_required_number_nullable_array_array operation. +// TestRequestRequiredIntegerUnixSecondsNullableArrayArray invokes test_request_required_integer_unix-seconds_nullable_array_array operation. // -// POST /test_request_required_number_nullable_array_array -func (c *Client) TestRequestRequiredNumberNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { +// POST /test_request_required_integer_unix-seconds_nullable_array_array +func (c *Client) TestRequestRequiredIntegerUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -15520,23 +15330,6 @@ func (c *Client) TestRequestRequiredNumberNullableArrayArray(ctx context.Context if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -15564,7 +15357,7 @@ func (c *Client) TestRequestRequiredNumberNullableArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15581,14 +15374,14 @@ func (c *Client) TestRequestRequiredNumberNullableArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_number_nullable_array_array" + u.Path += "/test_request_required_integer_unix-seconds_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredNumberNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15600,7 +15393,7 @@ func (c *Client) TestRequestRequiredNumberNullableArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredNumberNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15608,12 +15401,12 @@ func (c *Client) TestRequestRequiredNumberNullableArrayArray(ctx context.Context return result, nil } -// TestRequestRequiredString invokes test_request_required_string operation. +// TestRequestRequiredNull invokes test_request_required_null operation. // -// POST /test_request_required_string -func (c *Client) TestRequestRequiredString(ctx context.Context, request string) (res Error, err error) { +// POST /test_request_required_null +func (c *Client) TestRequestRequiredNull(ctx context.Context, request struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string"), + otelogen.OperationID("test_request_required_null"), } // Validate request before sending. @@ -15628,7 +15421,7 @@ func (c *Client) TestRequestRequiredString(ctx context.Context, request string) c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredString", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNull", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15645,14 +15438,14 @@ func (c *Client) TestRequestRequiredString(ctx context.Context, request string) stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string" + u.Path += "/test_request_required_null" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNullRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15664,7 +15457,7 @@ func (c *Client) TestRequestRequiredString(ctx context.Context, request string) defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringResponse(resp, span) + result, err := decodeTestRequestRequiredNullResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15672,12 +15465,12 @@ func (c *Client) TestRequestRequiredString(ctx context.Context, request string) return result, nil } -// TestRequestRequiredStringArray invokes test_request_required_string_array operation. +// TestRequestRequiredNullArray invokes test_request_required_null_array operation. // -// POST /test_request_required_string_array -func (c *Client) TestRequestRequiredStringArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_null_array +func (c *Client) TestRequestRequiredNullArray(ctx context.Context, request []struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_array"), + otelogen.OperationID("test_request_required_null_array"), } // Validate request before sending. if err := func() error { @@ -15700,7 +15493,7 @@ func (c *Client) TestRequestRequiredStringArray(ctx context.Context, request []s c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15717,14 +15510,14 @@ func (c *Client) TestRequestRequiredStringArray(ctx context.Context, request []s stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_array" + u.Path += "/test_request_required_null_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNullArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15736,7 +15529,7 @@ func (c *Client) TestRequestRequiredStringArray(ctx context.Context, request []s defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNullArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15744,12 +15537,12 @@ func (c *Client) TestRequestRequiredStringArray(ctx context.Context, request []s return result, nil } -// TestRequestRequiredStringArrayArray invokes test_request_required_string_array_array operation. +// TestRequestRequiredNullArrayArray invokes test_request_required_null_array_array operation. // -// POST /test_request_required_string_array_array -func (c *Client) TestRequestRequiredStringArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_null_array_array +func (c *Client) TestRequestRequiredNullArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_array_array"), + otelogen.OperationID("test_request_required_null_array_array"), } // Validate request before sending. if err := func() error { @@ -15789,7 +15582,7 @@ func (c *Client) TestRequestRequiredStringArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15806,14 +15599,14 @@ func (c *Client) TestRequestRequiredStringArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_array_array" + u.Path += "/test_request_required_null_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNullArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15825,7 +15618,7 @@ func (c *Client) TestRequestRequiredStringArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNullArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15833,12 +15626,12 @@ func (c *Client) TestRequestRequiredStringArrayArray(ctx context.Context, reques return result, nil } -// TestRequestRequiredStringBinary invokes test_request_required_string_binary operation. +// TestRequestRequiredNullNullable invokes test_request_required_null_nullable operation. // -// POST /test_request_required_string_binary -func (c *Client) TestRequestRequiredStringBinary(ctx context.Context, request string) (res Error, err error) { +// POST /test_request_required_null_nullable +func (c *Client) TestRequestRequiredNullNullable(ctx context.Context, request struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary"), + otelogen.OperationID("test_request_required_null_nullable"), } // Validate request before sending. @@ -15853,7 +15646,7 @@ func (c *Client) TestRequestRequiredStringBinary(ctx context.Context, request st c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinary", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15870,14 +15663,14 @@ func (c *Client) TestRequestRequiredStringBinary(ctx context.Context, request st stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_binary" + u.Path += "/test_request_required_null_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringBinaryRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNullNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15889,7 +15682,7 @@ func (c *Client) TestRequestRequiredStringBinary(ctx context.Context, request st defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringBinaryResponse(resp, span) + result, err := decodeTestRequestRequiredNullNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15897,12 +15690,12 @@ func (c *Client) TestRequestRequiredStringBinary(ctx context.Context, request st return result, nil } -// TestRequestRequiredStringBinaryArray invokes test_request_required_string_binary_array operation. +// TestRequestRequiredNullNullableArray invokes test_request_required_null_nullable_array operation. // -// POST /test_request_required_string_binary_array -func (c *Client) TestRequestRequiredStringBinaryArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_null_nullable_array +func (c *Client) TestRequestRequiredNullNullableArray(ctx context.Context, request []struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_array"), + otelogen.OperationID("test_request_required_null_nullable_array"), } // Validate request before sending. if err := func() error { @@ -15925,7 +15718,7 @@ func (c *Client) TestRequestRequiredStringBinaryArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -15942,14 +15735,14 @@ func (c *Client) TestRequestRequiredStringBinaryArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_binary_array" + u.Path += "/test_request_required_null_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringBinaryArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNullNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -15961,7 +15754,7 @@ func (c *Client) TestRequestRequiredStringBinaryArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringBinaryArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNullNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -15969,12 +15762,12 @@ func (c *Client) TestRequestRequiredStringBinaryArray(ctx context.Context, reque return result, nil } -// TestRequestRequiredStringBinaryArrayArray invokes test_request_required_string_binary_array_array operation. +// TestRequestRequiredNullNullableArrayArray invokes test_request_required_null_nullable_array_array operation. // -// POST /test_request_required_string_binary_array_array -func (c *Client) TestRequestRequiredStringBinaryArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_null_nullable_array_array +func (c *Client) TestRequestRequiredNullNullableArrayArray(ctx context.Context, request [][]struct{}) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_array_array"), + otelogen.OperationID("test_request_required_null_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -16014,7 +15807,7 @@ func (c *Client) TestRequestRequiredStringBinaryArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNullNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16031,14 +15824,14 @@ func (c *Client) TestRequestRequiredStringBinaryArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_binary_array_array" + u.Path += "/test_request_required_null_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringBinaryArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNullNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16050,7 +15843,7 @@ func (c *Client) TestRequestRequiredStringBinaryArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringBinaryArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNullNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16058,14 +15851,22 @@ func (c *Client) TestRequestRequiredStringBinaryArrayArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringBinaryNullable invokes test_request_required_string_binary_nullable operation. +// TestRequestRequiredNumber invokes test_request_required_number operation. // -// POST /test_request_required_string_binary_nullable -func (c *Client) TestRequestRequiredStringBinaryNullable(ctx context.Context, request NilString) (res Error, err error) { +// POST /test_request_required_number +func (c *Client) TestRequestRequiredNumber(ctx context.Context, request float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_nullable"), + otelogen.OperationID("test_request_required_number"), } // Validate request before sending. + if err := func() error { + if err := (validate.Float{}).Validate(float64(request)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -16078,7 +15879,7 @@ func (c *Client) TestRequestRequiredStringBinaryNullable(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumber", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16095,14 +15896,14 @@ func (c *Client) TestRequestRequiredStringBinaryNullable(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_binary_nullable" + u.Path += "/test_request_required_number" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringBinaryNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16114,7 +15915,7 @@ func (c *Client) TestRequestRequiredStringBinaryNullable(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringBinaryNullableResponse(resp, span) + result, err := decodeTestRequestRequiredNumberResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16122,18 +15923,35 @@ func (c *Client) TestRequestRequiredStringBinaryNullable(ctx context.Context, re return result, nil } -// TestRequestRequiredStringBinaryNullableArray invokes test_request_required_string_binary_nullable_array operation. +// TestRequestRequiredNumberArray invokes test_request_required_number_array operation. // -// POST /test_request_required_string_binary_nullable_array -func (c *Client) TestRequestRequiredStringBinaryNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_required_number_array +func (c *Client) TestRequestRequiredNumberArray(ctx context.Context, request []float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_nullable_array"), + otelogen.OperationID("test_request_required_number_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -16150,7 +15968,7 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16167,14 +15985,14 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_binary_nullable_array" + u.Path += "/test_request_required_number_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringBinaryNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16186,7 +16004,7 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringBinaryNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16194,12 +16012,12 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArray(ctx context.Contex return result, nil } -// TestRequestRequiredStringBinaryNullableArrayArray invokes test_request_required_string_binary_nullable_array_array operation. +// TestRequestRequiredNumberArrayArray invokes test_request_required_number_array_array operation. // -// POST /test_request_required_string_binary_nullable_array_array -func (c *Client) TestRequestRequiredStringBinaryNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_required_number_array_array +func (c *Client) TestRequestRequiredNumberArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_nullable_array_array"), + otelogen.OperationID("test_request_required_number_array_array"), } // Validate request before sending. if err := func() error { @@ -16212,6 +16030,23 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArrayArray(ctx context.C if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -16239,7 +16074,7 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArrayArray(ctx context.C c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16256,14 +16091,14 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArrayArray(ctx context.C stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_binary_nullable_array_array" + u.Path += "/test_request_required_number_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringBinaryNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16275,7 +16110,7 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArrayArray(ctx context.C defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16283,14 +16118,22 @@ func (c *Client) TestRequestRequiredStringBinaryNullableArrayArray(ctx context.C return result, nil } -// TestRequestRequiredStringByte invokes test_request_required_string_byte operation. +// TestRequestRequiredNumberDouble invokes test_request_required_number_double operation. // -// POST /test_request_required_string_byte -func (c *Client) TestRequestRequiredStringByte(ctx context.Context, request []byte) (res Error, err error) { +// POST /test_request_required_number_double +func (c *Client) TestRequestRequiredNumberDouble(ctx context.Context, request float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte"), + otelogen.OperationID("test_request_required_number_double"), } // Validate request before sending. + if err := func() error { + if err := (validate.Float{}).Validate(float64(request)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -16303,7 +16146,7 @@ func (c *Client) TestRequestRequiredStringByte(ctx context.Context, request []by c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByte", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDouble", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16320,14 +16163,14 @@ func (c *Client) TestRequestRequiredStringByte(ctx context.Context, request []by stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_byte" + u.Path += "/test_request_required_number_double" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringByteRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberDoubleRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16339,7 +16182,7 @@ func (c *Client) TestRequestRequiredStringByte(ctx context.Context, request []by defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringByteResponse(resp, span) + result, err := decodeTestRequestRequiredNumberDoubleResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16347,18 +16190,35 @@ func (c *Client) TestRequestRequiredStringByte(ctx context.Context, request []by return result, nil } -// TestRequestRequiredStringByteArray invokes test_request_required_string_byte_array operation. +// TestRequestRequiredNumberDoubleArray invokes test_request_required_number_double_array operation. // -// POST /test_request_required_string_byte_array -func (c *Client) TestRequestRequiredStringByteArray(ctx context.Context, request [][]byte) (res Error, err error) { +// POST /test_request_required_number_double_array +func (c *Client) TestRequestRequiredNumberDoubleArray(ctx context.Context, request []float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_array"), + otelogen.OperationID("test_request_required_number_double_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -16375,7 +16235,7 @@ func (c *Client) TestRequestRequiredStringByteArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16392,14 +16252,14 @@ func (c *Client) TestRequestRequiredStringByteArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_byte_array" + u.Path += "/test_request_required_number_double_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringByteArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberDoubleArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16411,7 +16271,7 @@ func (c *Client) TestRequestRequiredStringByteArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringByteArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberDoubleArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16419,12 +16279,12 @@ func (c *Client) TestRequestRequiredStringByteArray(ctx context.Context, request return result, nil } -// TestRequestRequiredStringByteArrayArray invokes test_request_required_string_byte_array_array operation. +// TestRequestRequiredNumberDoubleArrayArray invokes test_request_required_number_double_array_array operation. // -// POST /test_request_required_string_byte_array_array -func (c *Client) TestRequestRequiredStringByteArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { +// POST /test_request_required_number_double_array_array +func (c *Client) TestRequestRequiredNumberDoubleArrayArray(ctx context.Context, request [][]float64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_array_array"), + otelogen.OperationID("test_request_required_number_double_array_array"), } // Validate request before sending. if err := func() error { @@ -16437,6 +16297,23 @@ func (c *Client) TestRequestRequiredStringByteArrayArray(ctx context.Context, re if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -16464,7 +16341,7 @@ func (c *Client) TestRequestRequiredStringByteArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16481,14 +16358,14 @@ func (c *Client) TestRequestRequiredStringByteArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_byte_array_array" + u.Path += "/test_request_required_number_double_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringByteArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberDoubleArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16500,7 +16377,7 @@ func (c *Client) TestRequestRequiredStringByteArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringByteArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberDoubleArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16508,14 +16385,22 @@ func (c *Client) TestRequestRequiredStringByteArrayArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringByteNullable invokes test_request_required_string_byte_nullable operation. +// TestRequestRequiredNumberDoubleNullable invokes test_request_required_number_double_nullable operation. // -// POST /test_request_required_string_byte_nullable -func (c *Client) TestRequestRequiredStringByteNullable(ctx context.Context, request []byte) (res Error, err error) { +// POST /test_request_required_number_double_nullable +func (c *Client) TestRequestRequiredNumberDoubleNullable(ctx context.Context, request NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_nullable"), + otelogen.OperationID("test_request_required_number_double_nullable"), } // Validate request before sending. + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -16528,7 +16413,7 @@ func (c *Client) TestRequestRequiredStringByteNullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16545,14 +16430,14 @@ func (c *Client) TestRequestRequiredStringByteNullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_byte_nullable" + u.Path += "/test_request_required_number_double_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringByteNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberDoubleNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16564,7 +16449,7 @@ func (c *Client) TestRequestRequiredStringByteNullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringByteNullableResponse(resp, span) + result, err := decodeTestRequestRequiredNumberDoubleNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16572,18 +16457,35 @@ func (c *Client) TestRequestRequiredStringByteNullable(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringByteNullableArray invokes test_request_required_string_byte_nullable_array operation. +// TestRequestRequiredNumberDoubleNullableArray invokes test_request_required_number_double_nullable_array operation. // -// POST /test_request_required_string_byte_nullable_array -func (c *Client) TestRequestRequiredStringByteNullableArray(ctx context.Context, request [][]byte) (res Error, err error) { +// POST /test_request_required_number_double_nullable_array +func (c *Client) TestRequestRequiredNumberDoubleNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_nullable_array"), + otelogen.OperationID("test_request_required_number_double_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -16600,7 +16502,7 @@ func (c *Client) TestRequestRequiredStringByteNullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16617,14 +16519,14 @@ func (c *Client) TestRequestRequiredStringByteNullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_byte_nullable_array" + u.Path += "/test_request_required_number_double_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringByteNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberDoubleNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16636,7 +16538,7 @@ func (c *Client) TestRequestRequiredStringByteNullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringByteNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberDoubleNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16644,12 +16546,12 @@ func (c *Client) TestRequestRequiredStringByteNullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringByteNullableArrayArray invokes test_request_required_string_byte_nullable_array_array operation. +// TestRequestRequiredNumberDoubleNullableArrayArray invokes test_request_required_number_double_nullable_array_array operation. // -// POST /test_request_required_string_byte_nullable_array_array -func (c *Client) TestRequestRequiredStringByteNullableArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { +// POST /test_request_required_number_double_nullable_array_array +func (c *Client) TestRequestRequiredNumberDoubleNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_nullable_array_array"), + otelogen.OperationID("test_request_required_number_double_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -16662,6 +16564,23 @@ func (c *Client) TestRequestRequiredStringByteNullableArrayArray(ctx context.Con if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -16689,7 +16608,7 @@ func (c *Client) TestRequestRequiredStringByteNullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberDoubleNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16706,14 +16625,14 @@ func (c *Client) TestRequestRequiredStringByteNullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_byte_nullable_array_array" + u.Path += "/test_request_required_number_double_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringByteNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16725,7 +16644,7 @@ func (c *Client) TestRequestRequiredStringByteNullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringByteNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16733,14 +16652,22 @@ func (c *Client) TestRequestRequiredStringByteNullableArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredStringDate invokes test_request_required_string_date operation. +// TestRequestRequiredNumberFloat invokes test_request_required_number_float operation. // -// POST /test_request_required_string_date -func (c *Client) TestRequestRequiredStringDate(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_number_float +func (c *Client) TestRequestRequiredNumberFloat(ctx context.Context, request float32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date"), + otelogen.OperationID("test_request_required_number_float"), } // Validate request before sending. + if err := func() error { + if err := (validate.Float{}).Validate(float64(request)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -16753,7 +16680,7 @@ func (c *Client) TestRequestRequiredStringDate(ctx context.Context, request time c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDate", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloat", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16770,14 +16697,14 @@ func (c *Client) TestRequestRequiredStringDate(ctx context.Context, request time stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date" + u.Path += "/test_request_required_number_float" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberFloatRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16789,7 +16716,7 @@ func (c *Client) TestRequestRequiredStringDate(ctx context.Context, request time defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateResponse(resp, span) + result, err := decodeTestRequestRequiredNumberFloatResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16797,18 +16724,35 @@ func (c *Client) TestRequestRequiredStringDate(ctx context.Context, request time return result, nil } -// TestRequestRequiredStringDateArray invokes test_request_required_string_date_array operation. +// TestRequestRequiredNumberFloatArray invokes test_request_required_number_float_array operation. // -// POST /test_request_required_string_date_array -func (c *Client) TestRequestRequiredStringDateArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_number_float_array +func (c *Client) TestRequestRequiredNumberFloatArray(ctx context.Context, request []float32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_array"), + otelogen.OperationID("test_request_required_number_float_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -16825,7 +16769,7 @@ func (c *Client) TestRequestRequiredStringDateArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16842,14 +16786,14 @@ func (c *Client) TestRequestRequiredStringDateArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date_array" + u.Path += "/test_request_required_number_float_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberFloatArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16861,7 +16805,7 @@ func (c *Client) TestRequestRequiredStringDateArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberFloatArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16869,12 +16813,12 @@ func (c *Client) TestRequestRequiredStringDateArray(ctx context.Context, request return result, nil } -// TestRequestRequiredStringDateArrayArray invokes test_request_required_string_date_array_array operation. +// TestRequestRequiredNumberFloatArrayArray invokes test_request_required_number_float_array_array operation. // -// POST /test_request_required_string_date_array_array -func (c *Client) TestRequestRequiredStringDateArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_number_float_array_array +func (c *Client) TestRequestRequiredNumberFloatArrayArray(ctx context.Context, request [][]float32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_array_array"), + otelogen.OperationID("test_request_required_number_float_array_array"), } // Validate request before sending. if err := func() error { @@ -16887,6 +16831,23 @@ func (c *Client) TestRequestRequiredStringDateArrayArray(ctx context.Context, re if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -16914,7 +16875,7 @@ func (c *Client) TestRequestRequiredStringDateArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16931,14 +16892,14 @@ func (c *Client) TestRequestRequiredStringDateArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date_array_array" + u.Path += "/test_request_required_number_float_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberFloatArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -16950,7 +16911,7 @@ func (c *Client) TestRequestRequiredStringDateArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberFloatArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -16958,14 +16919,22 @@ func (c *Client) TestRequestRequiredStringDateArrayArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringDateNullable invokes test_request_required_string_date_nullable operation. +// TestRequestRequiredNumberFloatNullable invokes test_request_required_number_float_nullable operation. // -// POST /test_request_required_string_date_nullable -func (c *Client) TestRequestRequiredStringDateNullable(ctx context.Context, request NilDate) (res Error, err error) { +// POST /test_request_required_number_float_nullable +func (c *Client) TestRequestRequiredNumberFloatNullable(ctx context.Context, request NilFloat32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_nullable"), + otelogen.OperationID("test_request_required_number_float_nullable"), } // Validate request before sending. + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -16978,7 +16947,7 @@ func (c *Client) TestRequestRequiredStringDateNullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -16995,14 +16964,14 @@ func (c *Client) TestRequestRequiredStringDateNullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date_nullable" + u.Path += "/test_request_required_number_float_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberFloatNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17014,7 +16983,7 @@ func (c *Client) TestRequestRequiredStringDateNullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateNullableResponse(resp, span) + result, err := decodeTestRequestRequiredNumberFloatNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17022,18 +16991,35 @@ func (c *Client) TestRequestRequiredStringDateNullable(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringDateNullableArray invokes test_request_required_string_date_nullable_array operation. +// TestRequestRequiredNumberFloatNullableArray invokes test_request_required_number_float_nullable_array operation. // -// POST /test_request_required_string_date_nullable_array -func (c *Client) TestRequestRequiredStringDateNullableArray(ctx context.Context, request []NilDate) (res Error, err error) { +// POST /test_request_required_number_float_nullable_array +func (c *Client) TestRequestRequiredNumberFloatNullableArray(ctx context.Context, request []NilFloat32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_nullable_array"), + otelogen.OperationID("test_request_required_number_float_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -17050,7 +17036,7 @@ func (c *Client) TestRequestRequiredStringDateNullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17067,14 +17053,14 @@ func (c *Client) TestRequestRequiredStringDateNullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date_nullable_array" + u.Path += "/test_request_required_number_float_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberFloatNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17086,7 +17072,7 @@ func (c *Client) TestRequestRequiredStringDateNullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberFloatNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17094,12 +17080,12 @@ func (c *Client) TestRequestRequiredStringDateNullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringDateNullableArrayArray invokes test_request_required_string_date_nullable_array_array operation. +// TestRequestRequiredNumberFloatNullableArrayArray invokes test_request_required_number_float_nullable_array_array operation. // -// POST /test_request_required_string_date_nullable_array_array -func (c *Client) TestRequestRequiredStringDateNullableArrayArray(ctx context.Context, request [][]NilDate) (res Error, err error) { +// POST /test_request_required_number_float_nullable_array_array +func (c *Client) TestRequestRequiredNumberFloatNullableArrayArray(ctx context.Context, request [][]NilFloat32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_nullable_array_array"), + otelogen.OperationID("test_request_required_number_float_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -17112,6 +17098,23 @@ func (c *Client) TestRequestRequiredStringDateNullableArrayArray(ctx context.Con if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -17139,7 +17142,7 @@ func (c *Client) TestRequestRequiredStringDateNullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberFloatNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17156,14 +17159,14 @@ func (c *Client) TestRequestRequiredStringDateNullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date_nullable_array_array" + u.Path += "/test_request_required_number_float_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17175,7 +17178,7 @@ func (c *Client) TestRequestRequiredStringDateNullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17183,12 +17186,12 @@ func (c *Client) TestRequestRequiredStringDateNullableArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredStringDateTime invokes test_request_required_string_date-time operation. +// TestRequestRequiredNumberInt32 invokes test_request_required_number_int32 operation. // -// POST /test_request_required_string_date-time -func (c *Client) TestRequestRequiredStringDateTime(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_number_int32 +func (c *Client) TestRequestRequiredNumberInt32(ctx context.Context, request int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time"), + otelogen.OperationID("test_request_required_number_int32"), } // Validate request before sending. @@ -17203,7 +17206,7 @@ func (c *Client) TestRequestRequiredStringDateTime(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTime", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17220,14 +17223,14 @@ func (c *Client) TestRequestRequiredStringDateTime(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date-time" + u.Path += "/test_request_required_number_int32" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateTimeRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt32Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17239,7 +17242,7 @@ func (c *Client) TestRequestRequiredStringDateTime(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateTimeResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt32Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17247,12 +17250,12 @@ func (c *Client) TestRequestRequiredStringDateTime(ctx context.Context, request return result, nil } -// TestRequestRequiredStringDateTimeArray invokes test_request_required_string_date-time_array operation. +// TestRequestRequiredNumberInt32Array invokes test_request_required_number_int32_array operation. // -// POST /test_request_required_string_date-time_array -func (c *Client) TestRequestRequiredStringDateTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_number_int32_array +func (c *Client) TestRequestRequiredNumberInt32Array(ctx context.Context, request []int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_array"), + otelogen.OperationID("test_request_required_number_int32_array"), } // Validate request before sending. if err := func() error { @@ -17275,7 +17278,7 @@ func (c *Client) TestRequestRequiredStringDateTimeArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17292,14 +17295,14 @@ func (c *Client) TestRequestRequiredStringDateTimeArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date-time_array" + u.Path += "/test_request_required_number_int32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateTimeArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17311,7 +17314,7 @@ func (c *Client) TestRequestRequiredStringDateTimeArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateTimeArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17319,12 +17322,12 @@ func (c *Client) TestRequestRequiredStringDateTimeArray(ctx context.Context, req return result, nil } -// TestRequestRequiredStringDateTimeArrayArray invokes test_request_required_string_date-time_array_array operation. +// TestRequestRequiredNumberInt32ArrayArray invokes test_request_required_number_int32_array_array operation. // -// POST /test_request_required_string_date-time_array_array -func (c *Client) TestRequestRequiredStringDateTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_number_int32_array_array +func (c *Client) TestRequestRequiredNumberInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_array_array"), + otelogen.OperationID("test_request_required_number_int32_array_array"), } // Validate request before sending. if err := func() error { @@ -17364,7 +17367,7 @@ func (c *Client) TestRequestRequiredStringDateTimeArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17381,14 +17384,14 @@ func (c *Client) TestRequestRequiredStringDateTimeArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date-time_array_array" + u.Path += "/test_request_required_number_int32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateTimeArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17400,7 +17403,7 @@ func (c *Client) TestRequestRequiredStringDateTimeArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateTimeArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17408,12 +17411,12 @@ func (c *Client) TestRequestRequiredStringDateTimeArrayArray(ctx context.Context return result, nil } -// TestRequestRequiredStringDateTimeNullable invokes test_request_required_string_date-time_nullable operation. +// TestRequestRequiredNumberInt32Nullable invokes test_request_required_number_int32_nullable operation. // -// POST /test_request_required_string_date-time_nullable -func (c *Client) TestRequestRequiredStringDateTimeNullable(ctx context.Context, request NilDateTime) (res Error, err error) { +// POST /test_request_required_number_int32_nullable +func (c *Client) TestRequestRequiredNumberInt32Nullable(ctx context.Context, request NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_nullable"), + otelogen.OperationID("test_request_required_number_int32_nullable"), } // Validate request before sending. @@ -17428,7 +17431,7 @@ func (c *Client) TestRequestRequiredStringDateTimeNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17445,14 +17448,14 @@ func (c *Client) TestRequestRequiredStringDateTimeNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date-time_nullable" + u.Path += "/test_request_required_number_int32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateTimeNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17464,7 +17467,7 @@ func (c *Client) TestRequestRequiredStringDateTimeNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateTimeNullableResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17472,12 +17475,12 @@ func (c *Client) TestRequestRequiredStringDateTimeNullable(ctx context.Context, return result, nil } -// TestRequestRequiredStringDateTimeNullableArray invokes test_request_required_string_date-time_nullable_array operation. +// TestRequestRequiredNumberInt32NullableArray invokes test_request_required_number_int32_nullable_array operation. // -// POST /test_request_required_string_date-time_nullable_array -func (c *Client) TestRequestRequiredStringDateTimeNullableArray(ctx context.Context, request []NilDateTime) (res Error, err error) { +// POST /test_request_required_number_int32_nullable_array +func (c *Client) TestRequestRequiredNumberInt32NullableArray(ctx context.Context, request []NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_nullable_array"), + otelogen.OperationID("test_request_required_number_int32_nullable_array"), } // Validate request before sending. if err := func() error { @@ -17500,7 +17503,7 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17517,14 +17520,14 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date-time_nullable_array" + u.Path += "/test_request_required_number_int32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateTimeNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17536,7 +17539,7 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateTimeNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17544,12 +17547,12 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArray(ctx context.Cont return result, nil } -// TestRequestRequiredStringDateTimeNullableArrayArray invokes test_request_required_string_date-time_nullable_array_array operation. +// TestRequestRequiredNumberInt32NullableArrayArray invokes test_request_required_number_int32_nullable_array_array operation. // -// POST /test_request_required_string_date-time_nullable_array_array -func (c *Client) TestRequestRequiredStringDateTimeNullableArrayArray(ctx context.Context, request [][]NilDateTime) (res Error, err error) { +// POST /test_request_required_number_int32_nullable_array_array +func (c *Client) TestRequestRequiredNumberInt32NullableArrayArray(ctx context.Context, request [][]NilInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_nullable_array_array"), + otelogen.OperationID("test_request_required_number_int32_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -17589,7 +17592,7 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArrayArray(ctx context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17606,14 +17609,14 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArrayArray(ctx context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_date-time_nullable_array_array" + u.Path += "/test_request_required_number_int32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDateTimeNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17625,7 +17628,7 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArrayArray(ctx context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17633,12 +17636,12 @@ func (c *Client) TestRequestRequiredStringDateTimeNullableArrayArray(ctx context return result, nil } -// TestRequestRequiredStringDuration invokes test_request_required_string_duration operation. +// TestRequestRequiredNumberInt64 invokes test_request_required_number_int64 operation. // -// POST /test_request_required_string_duration -func (c *Client) TestRequestRequiredStringDuration(ctx context.Context, request time.Duration) (res Error, err error) { +// POST /test_request_required_number_int64 +func (c *Client) TestRequestRequiredNumberInt64(ctx context.Context, request int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration"), + otelogen.OperationID("test_request_required_number_int64"), } // Validate request before sending. @@ -17653,7 +17656,7 @@ func (c *Client) TestRequestRequiredStringDuration(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDuration", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17670,14 +17673,14 @@ func (c *Client) TestRequestRequiredStringDuration(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_duration" + u.Path += "/test_request_required_number_int64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDurationRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17689,7 +17692,7 @@ func (c *Client) TestRequestRequiredStringDuration(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDurationResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17697,12 +17700,12 @@ func (c *Client) TestRequestRequiredStringDuration(ctx context.Context, request return result, nil } -// TestRequestRequiredStringDurationArray invokes test_request_required_string_duration_array operation. +// TestRequestRequiredNumberInt64Array invokes test_request_required_number_int64_array operation. // -// POST /test_request_required_string_duration_array -func (c *Client) TestRequestRequiredStringDurationArray(ctx context.Context, request []time.Duration) (res Error, err error) { +// POST /test_request_required_number_int64_array +func (c *Client) TestRequestRequiredNumberInt64Array(ctx context.Context, request []int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_array"), + otelogen.OperationID("test_request_required_number_int64_array"), } // Validate request before sending. if err := func() error { @@ -17725,7 +17728,7 @@ func (c *Client) TestRequestRequiredStringDurationArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17742,14 +17745,14 @@ func (c *Client) TestRequestRequiredStringDurationArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_duration_array" + u.Path += "/test_request_required_number_int64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDurationArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17761,7 +17764,7 @@ func (c *Client) TestRequestRequiredStringDurationArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDurationArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17769,12 +17772,12 @@ func (c *Client) TestRequestRequiredStringDurationArray(ctx context.Context, req return result, nil } -// TestRequestRequiredStringDurationArrayArray invokes test_request_required_string_duration_array_array operation. +// TestRequestRequiredNumberInt64ArrayArray invokes test_request_required_number_int64_array_array operation. // -// POST /test_request_required_string_duration_array_array -func (c *Client) TestRequestRequiredStringDurationArrayArray(ctx context.Context, request [][]time.Duration) (res Error, err error) { +// POST /test_request_required_number_int64_array_array +func (c *Client) TestRequestRequiredNumberInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_array_array"), + otelogen.OperationID("test_request_required_number_int64_array_array"), } // Validate request before sending. if err := func() error { @@ -17814,7 +17817,7 @@ func (c *Client) TestRequestRequiredStringDurationArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17831,14 +17834,14 @@ func (c *Client) TestRequestRequiredStringDurationArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_duration_array_array" + u.Path += "/test_request_required_number_int64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDurationArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17850,7 +17853,7 @@ func (c *Client) TestRequestRequiredStringDurationArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDurationArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17858,12 +17861,12 @@ func (c *Client) TestRequestRequiredStringDurationArrayArray(ctx context.Context return result, nil } -// TestRequestRequiredStringDurationNullable invokes test_request_required_string_duration_nullable operation. +// TestRequestRequiredNumberInt64Nullable invokes test_request_required_number_int64_nullable operation. // -// POST /test_request_required_string_duration_nullable -func (c *Client) TestRequestRequiredStringDurationNullable(ctx context.Context, request NilDuration) (res Error, err error) { +// POST /test_request_required_number_int64_nullable +func (c *Client) TestRequestRequiredNumberInt64Nullable(ctx context.Context, request NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_nullable"), + otelogen.OperationID("test_request_required_number_int64_nullable"), } // Validate request before sending. @@ -17878,7 +17881,7 @@ func (c *Client) TestRequestRequiredStringDurationNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17895,14 +17898,14 @@ func (c *Client) TestRequestRequiredStringDurationNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_duration_nullable" + u.Path += "/test_request_required_number_int64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDurationNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17914,7 +17917,7 @@ func (c *Client) TestRequestRequiredStringDurationNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDurationNullableResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17922,12 +17925,12 @@ func (c *Client) TestRequestRequiredStringDurationNullable(ctx context.Context, return result, nil } -// TestRequestRequiredStringDurationNullableArray invokes test_request_required_string_duration_nullable_array operation. +// TestRequestRequiredNumberInt64NullableArray invokes test_request_required_number_int64_nullable_array operation. // -// POST /test_request_required_string_duration_nullable_array -func (c *Client) TestRequestRequiredStringDurationNullableArray(ctx context.Context, request []NilDuration) (res Error, err error) { +// POST /test_request_required_number_int64_nullable_array +func (c *Client) TestRequestRequiredNumberInt64NullableArray(ctx context.Context, request []NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_nullable_array"), + otelogen.OperationID("test_request_required_number_int64_nullable_array"), } // Validate request before sending. if err := func() error { @@ -17950,7 +17953,7 @@ func (c *Client) TestRequestRequiredStringDurationNullableArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -17967,14 +17970,14 @@ func (c *Client) TestRequestRequiredStringDurationNullableArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_duration_nullable_array" + u.Path += "/test_request_required_number_int64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDurationNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -17986,7 +17989,7 @@ func (c *Client) TestRequestRequiredStringDurationNullableArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDurationNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -17994,12 +17997,12 @@ func (c *Client) TestRequestRequiredStringDurationNullableArray(ctx context.Cont return result, nil } -// TestRequestRequiredStringDurationNullableArrayArray invokes test_request_required_string_duration_nullable_array_array operation. +// TestRequestRequiredNumberInt64NullableArrayArray invokes test_request_required_number_int64_nullable_array_array operation. // -// POST /test_request_required_string_duration_nullable_array_array -func (c *Client) TestRequestRequiredStringDurationNullableArrayArray(ctx context.Context, request [][]NilDuration) (res Error, err error) { +// POST /test_request_required_number_int64_nullable_array_array +func (c *Client) TestRequestRequiredNumberInt64NullableArrayArray(ctx context.Context, request [][]NilInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_nullable_array_array"), + otelogen.OperationID("test_request_required_number_int64_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -18039,7 +18042,7 @@ func (c *Client) TestRequestRequiredStringDurationNullableArrayArray(ctx context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18056,14 +18059,14 @@ func (c *Client) TestRequestRequiredStringDurationNullableArrayArray(ctx context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_duration_nullable_array_array" + u.Path += "/test_request_required_number_int64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringDurationNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18075,7 +18078,7 @@ func (c *Client) TestRequestRequiredStringDurationNullableArrayArray(ctx context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringDurationNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18083,25 +18086,17 @@ func (c *Client) TestRequestRequiredStringDurationNullableArrayArray(ctx context return result, nil } -// TestRequestRequiredStringEmail invokes test_request_required_string_email operation. +// TestRequestRequiredNumberNullable invokes test_request_required_number_nullable operation. // -// POST /test_request_required_string_email -func (c *Client) TestRequestRequiredStringEmail(ctx context.Context, request string) (res Error, err error) { +// POST /test_request_required_number_nullable +func (c *Client) TestRequestRequiredNumberNullable(ctx context.Context, request NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email"), + otelogen.OperationID("test_request_required_number_nullable"), } // Validate request before sending. if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request)); err != nil { - return errors.Wrap(err, "string") + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") } return nil }(); err != nil { @@ -18119,7 +18114,7 @@ func (c *Client) TestRequestRequiredStringEmail(ctx context.Context, request str c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmail", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18136,14 +18131,14 @@ func (c *Client) TestRequestRequiredStringEmail(ctx context.Context, request str stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_email" + u.Path += "/test_request_required_number_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringEmailRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18155,7 +18150,7 @@ func (c *Client) TestRequestRequiredStringEmail(ctx context.Context, request str defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringEmailResponse(resp, span) + result, err := decodeTestRequestRequiredNumberNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18163,12 +18158,12 @@ func (c *Client) TestRequestRequiredStringEmail(ctx context.Context, request str return result, nil } -// TestRequestRequiredStringEmailArray invokes test_request_required_string_email_array operation. +// TestRequestRequiredNumberNullableArray invokes test_request_required_number_nullable_array operation. // -// POST /test_request_required_string_email_array -func (c *Client) TestRequestRequiredStringEmailArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_number_nullable_array +func (c *Client) TestRequestRequiredNumberNullableArray(ctx context.Context, request []NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_array"), + otelogen.OperationID("test_request_required_number_nullable_array"), } // Validate request before sending. if err := func() error { @@ -18178,16 +18173,8 @@ func (c *Client) TestRequestRequiredStringEmailArray(ctx context.Context, reques var failures []validate.FieldError for i, elem := range request { if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") } return nil }(); err != nil { @@ -18216,7 +18203,7 @@ func (c *Client) TestRequestRequiredStringEmailArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18233,14 +18220,14 @@ func (c *Client) TestRequestRequiredStringEmailArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_email_array" + u.Path += "/test_request_required_number_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringEmailArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18252,7 +18239,7 @@ func (c *Client) TestRequestRequiredStringEmailArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringEmailArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18260,12 +18247,12 @@ func (c *Client) TestRequestRequiredStringEmailArray(ctx context.Context, reques return result, nil } -// TestRequestRequiredStringEmailArrayArray invokes test_request_required_string_email_array_array operation. +// TestRequestRequiredNumberNullableArrayArray invokes test_request_required_number_nullable_array_array operation. // -// POST /test_request_required_string_email_array_array -func (c *Client) TestRequestRequiredStringEmailArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_number_nullable_array_array +func (c *Client) TestRequestRequiredNumberNullableArrayArray(ctx context.Context, request [][]NilFloat64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_array_array"), + otelogen.OperationID("test_request_required_number_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -18281,16 +18268,8 @@ func (c *Client) TestRequestRequiredStringEmailArrayArray(ctx context.Context, r var failures []validate.FieldError for i, elem := range elem { if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") } return nil }(); err != nil { @@ -18330,7 +18309,7 @@ func (c *Client) TestRequestRequiredStringEmailArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredNumberNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18347,14 +18326,14 @@ func (c *Client) TestRequestRequiredStringEmailArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_email_array_array" + u.Path += "/test_request_required_number_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringEmailArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredNumberNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18366,7 +18345,7 @@ func (c *Client) TestRequestRequiredStringEmailArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringEmailArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredNumberNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18374,30 +18353,14 @@ func (c *Client) TestRequestRequiredStringEmailArrayArray(ctx context.Context, r return result, nil } -// TestRequestRequiredStringEmailNullable invokes test_request_required_string_email_nullable operation. +// TestRequestRequiredString invokes test_request_required_string operation. // -// POST /test_request_required_string_email_nullable -func (c *Client) TestRequestRequiredStringEmailNullable(ctx context.Context, request NilString) (res Error, err error) { +// POST /test_request_required_string +func (c *Client) TestRequestRequiredString(ctx context.Context, request string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_nullable"), + otelogen.OperationID("test_request_required_string"), } // Validate request before sending. - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -18410,7 +18373,7 @@ func (c *Client) TestRequestRequiredStringEmailNullable(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredString", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18427,14 +18390,14 @@ func (c *Client) TestRequestRequiredStringEmailNullable(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_email_nullable" + u.Path += "/test_request_required_string" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringEmailNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18446,7 +18409,7 @@ func (c *Client) TestRequestRequiredStringEmailNullable(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringEmailNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18454,43 +18417,18 @@ func (c *Client) TestRequestRequiredStringEmailNullable(ctx context.Context, req return result, nil } -// TestRequestRequiredStringEmailNullableArray invokes test_request_required_string_email_nullable_array operation. +// TestRequestRequiredStringArray invokes test_request_required_string_array operation. // -// POST /test_request_required_string_email_nullable_array -func (c *Client) TestRequestRequiredStringEmailNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_required_string_array +func (c *Client) TestRequestRequiredStringArray(ctx context.Context, request []string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_nullable_array"), + otelogen.OperationID("test_request_required_string_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -18507,7 +18445,7 @@ func (c *Client) TestRequestRequiredStringEmailNullableArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18524,14 +18462,14 @@ func (c *Client) TestRequestRequiredStringEmailNullableArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_email_nullable_array" + u.Path += "/test_request_required_string_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringEmailNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18543,7 +18481,7 @@ func (c *Client) TestRequestRequiredStringEmailNullableArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringEmailNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18551,12 +18489,12 @@ func (c *Client) TestRequestRequiredStringEmailNullableArray(ctx context.Context return result, nil } -// TestRequestRequiredStringEmailNullableArrayArray invokes test_request_required_string_email_nullable_array_array operation. +// TestRequestRequiredStringArrayArray invokes test_request_required_string_array_array operation. // -// POST /test_request_required_string_email_nullable_array_array -func (c *Client) TestRequestRequiredStringEmailNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_required_string_array_array +func (c *Client) TestRequestRequiredStringArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_nullable_array_array"), + otelogen.OperationID("test_request_required_string_array_array"), } // Validate request before sending. if err := func() error { @@ -18569,31 +18507,6 @@ func (c *Client) TestRequestRequiredStringEmailNullableArrayArray(ctx context.Co if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -18621,7 +18534,7 @@ func (c *Client) TestRequestRequiredStringEmailNullableArrayArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18638,14 +18551,14 @@ func (c *Client) TestRequestRequiredStringEmailNullableArrayArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_email_nullable_array_array" + u.Path += "/test_request_required_string_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringEmailNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18657,7 +18570,7 @@ func (c *Client) TestRequestRequiredStringEmailNullableArrayArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringEmailNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18665,30 +18578,14 @@ func (c *Client) TestRequestRequiredStringEmailNullableArrayArray(ctx context.Co return result, nil } -// TestRequestRequiredStringHostname invokes test_request_required_string_hostname operation. +// TestRequestRequiredStringBinary invokes test_request_required_string_binary operation. // -// POST /test_request_required_string_hostname -func (c *Client) TestRequestRequiredStringHostname(ctx context.Context, request string) (res Error, err error) { +// POST /test_request_required_string_binary +func (c *Client) TestRequestRequiredStringBinary(ctx context.Context, request string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname"), + otelogen.OperationID("test_request_required_string_binary"), } // Validate request before sending. - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -18701,7 +18598,7 @@ func (c *Client) TestRequestRequiredStringHostname(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostname", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinary", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18718,14 +18615,14 @@ func (c *Client) TestRequestRequiredStringHostname(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_hostname" + u.Path += "/test_request_required_string_binary" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringHostnameRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringBinaryRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18737,7 +18634,7 @@ func (c *Client) TestRequestRequiredStringHostname(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringHostnameResponse(resp, span) + result, err := decodeTestRequestRequiredStringBinaryResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18745,43 +18642,18 @@ func (c *Client) TestRequestRequiredStringHostname(ctx context.Context, request return result, nil } -// TestRequestRequiredStringHostnameArray invokes test_request_required_string_hostname_array operation. +// TestRequestRequiredStringBinaryArray invokes test_request_required_string_binary_array operation. // -// POST /test_request_required_string_hostname_array -func (c *Client) TestRequestRequiredStringHostnameArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_string_binary_array +func (c *Client) TestRequestRequiredStringBinaryArray(ctx context.Context, request []string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_array"), + otelogen.OperationID("test_request_required_string_binary_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -18798,7 +18670,7 @@ func (c *Client) TestRequestRequiredStringHostnameArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18815,14 +18687,14 @@ func (c *Client) TestRequestRequiredStringHostnameArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_hostname_array" + u.Path += "/test_request_required_string_binary_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringHostnameArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringBinaryArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18834,7 +18706,7 @@ func (c *Client) TestRequestRequiredStringHostnameArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringHostnameArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringBinaryArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18842,12 +18714,12 @@ func (c *Client) TestRequestRequiredStringHostnameArray(ctx context.Context, req return result, nil } -// TestRequestRequiredStringHostnameArrayArray invokes test_request_required_string_hostname_array_array operation. +// TestRequestRequiredStringBinaryArrayArray invokes test_request_required_string_binary_array_array operation. // -// POST /test_request_required_string_hostname_array_array -func (c *Client) TestRequestRequiredStringHostnameArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_string_binary_array_array +func (c *Client) TestRequestRequiredStringBinaryArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_array_array"), + otelogen.OperationID("test_request_required_string_binary_array_array"), } // Validate request before sending. if err := func() error { @@ -18860,31 +18732,6 @@ func (c *Client) TestRequestRequiredStringHostnameArrayArray(ctx context.Context if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -18912,7 +18759,7 @@ func (c *Client) TestRequestRequiredStringHostnameArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -18929,14 +18776,14 @@ func (c *Client) TestRequestRequiredStringHostnameArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_hostname_array_array" + u.Path += "/test_request_required_string_binary_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringHostnameArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringBinaryArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -18948,7 +18795,7 @@ func (c *Client) TestRequestRequiredStringHostnameArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringHostnameArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringBinaryArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -18956,30 +18803,14 @@ func (c *Client) TestRequestRequiredStringHostnameArrayArray(ctx context.Context return result, nil } -// TestRequestRequiredStringHostnameNullable invokes test_request_required_string_hostname_nullable operation. +// TestRequestRequiredStringBinaryNullable invokes test_request_required_string_binary_nullable operation. // -// POST /test_request_required_string_hostname_nullable -func (c *Client) TestRequestRequiredStringHostnameNullable(ctx context.Context, request NilString) (res Error, err error) { +// POST /test_request_required_string_binary_nullable +func (c *Client) TestRequestRequiredStringBinaryNullable(ctx context.Context, request NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_nullable"), + otelogen.OperationID("test_request_required_string_binary_nullable"), } // Validate request before sending. - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -18992,7 +18823,7 @@ func (c *Client) TestRequestRequiredStringHostnameNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19009,14 +18840,14 @@ func (c *Client) TestRequestRequiredStringHostnameNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_hostname_nullable" + u.Path += "/test_request_required_string_binary_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringHostnameNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringBinaryNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19028,7 +18859,7 @@ func (c *Client) TestRequestRequiredStringHostnameNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringHostnameNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringBinaryNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19036,43 +18867,18 @@ func (c *Client) TestRequestRequiredStringHostnameNullable(ctx context.Context, return result, nil } -// TestRequestRequiredStringHostnameNullableArray invokes test_request_required_string_hostname_nullable_array operation. +// TestRequestRequiredStringBinaryNullableArray invokes test_request_required_string_binary_nullable_array operation. // -// POST /test_request_required_string_hostname_nullable_array -func (c *Client) TestRequestRequiredStringHostnameNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_required_string_binary_nullable_array +func (c *Client) TestRequestRequiredStringBinaryNullableArray(ctx context.Context, request []NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_nullable_array"), + otelogen.OperationID("test_request_required_string_binary_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -19089,7 +18895,7 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19106,14 +18912,14 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_hostname_nullable_array" + u.Path += "/test_request_required_string_binary_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringHostnameNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringBinaryNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19125,7 +18931,7 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringHostnameNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringBinaryNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19133,12 +18939,12 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArray(ctx context.Cont return result, nil } -// TestRequestRequiredStringHostnameNullableArrayArray invokes test_request_required_string_hostname_nullable_array_array operation. +// TestRequestRequiredStringBinaryNullableArrayArray invokes test_request_required_string_binary_nullable_array_array operation. // -// POST /test_request_required_string_hostname_nullable_array_array -func (c *Client) TestRequestRequiredStringHostnameNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_required_string_binary_nullable_array_array +func (c *Client) TestRequestRequiredStringBinaryNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_nullable_array_array"), + otelogen.OperationID("test_request_required_string_binary_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -19151,31 +18957,6 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArrayArray(ctx context if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -19203,7 +18984,7 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArrayArray(ctx context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringBinaryNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19220,14 +19001,14 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArrayArray(ctx context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_hostname_nullable_array_array" + u.Path += "/test_request_required_string_binary_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringHostnameNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringBinaryNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19239,7 +19020,7 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArrayArray(ctx context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19247,12 +19028,12 @@ func (c *Client) TestRequestRequiredStringHostnameNullableArrayArray(ctx context return result, nil } -// TestRequestRequiredStringIP invokes test_request_required_string_ip operation. +// TestRequestRequiredStringByte invokes test_request_required_string_byte operation. // -// POST /test_request_required_string_ip -func (c *Client) TestRequestRequiredStringIP(ctx context.Context, request netip.Addr) (res Error, err error) { +// POST /test_request_required_string_byte +func (c *Client) TestRequestRequiredStringByte(ctx context.Context, request []byte) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip"), + otelogen.OperationID("test_request_required_string_byte"), } // Validate request before sending. @@ -19267,7 +19048,7 @@ func (c *Client) TestRequestRequiredStringIP(ctx context.Context, request netip. c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIP", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByte", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19284,14 +19065,14 @@ func (c *Client) TestRequestRequiredStringIP(ctx context.Context, request netip. stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ip" + u.Path += "/test_request_required_string_byte" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIPRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringByteRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19303,7 +19084,7 @@ func (c *Client) TestRequestRequiredStringIP(ctx context.Context, request netip. defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIPResponse(resp, span) + result, err := decodeTestRequestRequiredStringByteResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19311,12 +19092,12 @@ func (c *Client) TestRequestRequiredStringIP(ctx context.Context, request netip. return result, nil } -// TestRequestRequiredStringIPArray invokes test_request_required_string_ip_array operation. +// TestRequestRequiredStringByteArray invokes test_request_required_string_byte_array operation. // -// POST /test_request_required_string_ip_array -func (c *Client) TestRequestRequiredStringIPArray(ctx context.Context, request []netip.Addr) (res Error, err error) { +// POST /test_request_required_string_byte_array +func (c *Client) TestRequestRequiredStringByteArray(ctx context.Context, request [][]byte) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_array"), + otelogen.OperationID("test_request_required_string_byte_array"), } // Validate request before sending. if err := func() error { @@ -19339,7 +19120,7 @@ func (c *Client) TestRequestRequiredStringIPArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19356,14 +19137,14 @@ func (c *Client) TestRequestRequiredStringIPArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ip_array" + u.Path += "/test_request_required_string_byte_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIPArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringByteArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19375,7 +19156,7 @@ func (c *Client) TestRequestRequiredStringIPArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIPArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringByteArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19383,12 +19164,12 @@ func (c *Client) TestRequestRequiredStringIPArray(ctx context.Context, request [ return result, nil } -// TestRequestRequiredStringIPArrayArray invokes test_request_required_string_ip_array_array operation. +// TestRequestRequiredStringByteArrayArray invokes test_request_required_string_byte_array_array operation. // -// POST /test_request_required_string_ip_array_array -func (c *Client) TestRequestRequiredStringIPArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { +// POST /test_request_required_string_byte_array_array +func (c *Client) TestRequestRequiredStringByteArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_array_array"), + otelogen.OperationID("test_request_required_string_byte_array_array"), } // Validate request before sending. if err := func() error { @@ -19428,7 +19209,7 @@ func (c *Client) TestRequestRequiredStringIPArrayArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19445,14 +19226,14 @@ func (c *Client) TestRequestRequiredStringIPArrayArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ip_array_array" + u.Path += "/test_request_required_string_byte_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIPArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringByteArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19464,7 +19245,7 @@ func (c *Client) TestRequestRequiredStringIPArrayArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIPArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringByteArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19472,12 +19253,12 @@ func (c *Client) TestRequestRequiredStringIPArrayArray(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringIPNullable invokes test_request_required_string_ip_nullable operation. +// TestRequestRequiredStringByteNullable invokes test_request_required_string_byte_nullable operation. // -// POST /test_request_required_string_ip_nullable -func (c *Client) TestRequestRequiredStringIPNullable(ctx context.Context, request NilIP) (res Error, err error) { +// POST /test_request_required_string_byte_nullable +func (c *Client) TestRequestRequiredStringByteNullable(ctx context.Context, request []byte) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_nullable"), + otelogen.OperationID("test_request_required_string_byte_nullable"), } // Validate request before sending. @@ -19492,7 +19273,7 @@ func (c *Client) TestRequestRequiredStringIPNullable(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19509,14 +19290,14 @@ func (c *Client) TestRequestRequiredStringIPNullable(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ip_nullable" + u.Path += "/test_request_required_string_byte_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIPNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringByteNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19528,7 +19309,7 @@ func (c *Client) TestRequestRequiredStringIPNullable(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIPNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringByteNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19536,12 +19317,12 @@ func (c *Client) TestRequestRequiredStringIPNullable(ctx context.Context, reques return result, nil } -// TestRequestRequiredStringIPNullableArray invokes test_request_required_string_ip_nullable_array operation. +// TestRequestRequiredStringByteNullableArray invokes test_request_required_string_byte_nullable_array operation. // -// POST /test_request_required_string_ip_nullable_array -func (c *Client) TestRequestRequiredStringIPNullableArray(ctx context.Context, request []NilIP) (res Error, err error) { +// POST /test_request_required_string_byte_nullable_array +func (c *Client) TestRequestRequiredStringByteNullableArray(ctx context.Context, request [][]byte) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_nullable_array"), + otelogen.OperationID("test_request_required_string_byte_nullable_array"), } // Validate request before sending. if err := func() error { @@ -19564,7 +19345,7 @@ func (c *Client) TestRequestRequiredStringIPNullableArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19581,14 +19362,14 @@ func (c *Client) TestRequestRequiredStringIPNullableArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ip_nullable_array" + u.Path += "/test_request_required_string_byte_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIPNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringByteNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19600,7 +19381,7 @@ func (c *Client) TestRequestRequiredStringIPNullableArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIPNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringByteNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19608,12 +19389,12 @@ func (c *Client) TestRequestRequiredStringIPNullableArray(ctx context.Context, r return result, nil } -// TestRequestRequiredStringIPNullableArrayArray invokes test_request_required_string_ip_nullable_array_array operation. +// TestRequestRequiredStringByteNullableArrayArray invokes test_request_required_string_byte_nullable_array_array operation. // -// POST /test_request_required_string_ip_nullable_array_array -func (c *Client) TestRequestRequiredStringIPNullableArrayArray(ctx context.Context, request [][]NilIP) (res Error, err error) { +// POST /test_request_required_string_byte_nullable_array_array +func (c *Client) TestRequestRequiredStringByteNullableArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_nullable_array_array"), + otelogen.OperationID("test_request_required_string_byte_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -19653,7 +19434,7 @@ func (c *Client) TestRequestRequiredStringIPNullableArrayArray(ctx context.Conte c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringByteNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19670,14 +19451,14 @@ func (c *Client) TestRequestRequiredStringIPNullableArrayArray(ctx context.Conte stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ip_nullable_array_array" + u.Path += "/test_request_required_string_byte_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIPNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringByteNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19689,7 +19470,7 @@ func (c *Client) TestRequestRequiredStringIPNullableArrayArray(ctx context.Conte defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIPNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringByteNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19697,12 +19478,12 @@ func (c *Client) TestRequestRequiredStringIPNullableArrayArray(ctx context.Conte return result, nil } -// TestRequestRequiredStringInt32 invokes test_request_required_string_int32 operation. +// TestRequestRequiredStringDate invokes test_request_required_string_date operation. // -// POST /test_request_required_string_int32 -func (c *Client) TestRequestRequiredStringInt32(ctx context.Context, request int32) (res Error, err error) { +// POST /test_request_required_string_date +func (c *Client) TestRequestRequiredStringDate(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32"), + otelogen.OperationID("test_request_required_string_date"), } // Validate request before sending. @@ -19717,7 +19498,7 @@ func (c *Client) TestRequestRequiredStringInt32(ctx context.Context, request int c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDate", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19734,14 +19515,14 @@ func (c *Client) TestRequestRequiredStringInt32(ctx context.Context, request int stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int32" + u.Path += "/test_request_required_string_date" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt32Request(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19753,7 +19534,7 @@ func (c *Client) TestRequestRequiredStringInt32(ctx context.Context, request int defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt32Response(resp, span) + result, err := decodeTestRequestRequiredStringDateResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19761,12 +19542,12 @@ func (c *Client) TestRequestRequiredStringInt32(ctx context.Context, request int return result, nil } -// TestRequestRequiredStringInt32Array invokes test_request_required_string_int32_array operation. +// TestRequestRequiredStringDateArray invokes test_request_required_string_date_array operation. // -// POST /test_request_required_string_int32_array -func (c *Client) TestRequestRequiredStringInt32Array(ctx context.Context, request []int32) (res Error, err error) { +// POST /test_request_required_string_date_array +func (c *Client) TestRequestRequiredStringDateArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_array"), + otelogen.OperationID("test_request_required_string_date_array"), } // Validate request before sending. if err := func() error { @@ -19789,7 +19570,7 @@ func (c *Client) TestRequestRequiredStringInt32Array(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19806,14 +19587,14 @@ func (c *Client) TestRequestRequiredStringInt32Array(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int32_array" + u.Path += "/test_request_required_string_date_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt32ArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19825,7 +19606,7 @@ func (c *Client) TestRequestRequiredStringInt32Array(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt32ArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19833,12 +19614,12 @@ func (c *Client) TestRequestRequiredStringInt32Array(ctx context.Context, reques return result, nil } -// TestRequestRequiredStringInt32ArrayArray invokes test_request_required_string_int32_array_array operation. +// TestRequestRequiredStringDateArrayArray invokes test_request_required_string_date_array_array operation. // -// POST /test_request_required_string_int32_array_array -func (c *Client) TestRequestRequiredStringInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { +// POST /test_request_required_string_date_array_array +func (c *Client) TestRequestRequiredStringDateArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_array_array"), + otelogen.OperationID("test_request_required_string_date_array_array"), } // Validate request before sending. if err := func() error { @@ -19878,7 +19659,7 @@ func (c *Client) TestRequestRequiredStringInt32ArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19895,14 +19676,14 @@ func (c *Client) TestRequestRequiredStringInt32ArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int32_array_array" + u.Path += "/test_request_required_string_date_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt32ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19914,7 +19695,7 @@ func (c *Client) TestRequestRequiredStringInt32ArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt32ArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19922,12 +19703,12 @@ func (c *Client) TestRequestRequiredStringInt32ArrayArray(ctx context.Context, r return result, nil } -// TestRequestRequiredStringInt32Nullable invokes test_request_required_string_int32_nullable operation. +// TestRequestRequiredStringDateNullable invokes test_request_required_string_date_nullable operation. // -// POST /test_request_required_string_int32_nullable -func (c *Client) TestRequestRequiredStringInt32Nullable(ctx context.Context, request NilStringInt32) (res Error, err error) { +// POST /test_request_required_string_date_nullable +func (c *Client) TestRequestRequiredStringDateNullable(ctx context.Context, request NilDate) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_nullable"), + otelogen.OperationID("test_request_required_string_date_nullable"), } // Validate request before sending. @@ -19942,7 +19723,7 @@ func (c *Client) TestRequestRequiredStringInt32Nullable(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -19959,14 +19740,14 @@ func (c *Client) TestRequestRequiredStringInt32Nullable(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int32_nullable" + u.Path += "/test_request_required_string_date_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt32NullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -19978,7 +19759,7 @@ func (c *Client) TestRequestRequiredStringInt32Nullable(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt32NullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -19986,12 +19767,12 @@ func (c *Client) TestRequestRequiredStringInt32Nullable(ctx context.Context, req return result, nil } -// TestRequestRequiredStringInt32NullableArray invokes test_request_required_string_int32_nullable_array operation. +// TestRequestRequiredStringDateNullableArray invokes test_request_required_string_date_nullable_array operation. // -// POST /test_request_required_string_int32_nullable_array -func (c *Client) TestRequestRequiredStringInt32NullableArray(ctx context.Context, request []NilStringInt32) (res Error, err error) { +// POST /test_request_required_string_date_nullable_array +func (c *Client) TestRequestRequiredStringDateNullableArray(ctx context.Context, request []NilDate) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_nullable_array"), + otelogen.OperationID("test_request_required_string_date_nullable_array"), } // Validate request before sending. if err := func() error { @@ -20014,7 +19795,7 @@ func (c *Client) TestRequestRequiredStringInt32NullableArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20031,14 +19812,14 @@ func (c *Client) TestRequestRequiredStringInt32NullableArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int32_nullable_array" + u.Path += "/test_request_required_string_date_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt32NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20050,7 +19831,7 @@ func (c *Client) TestRequestRequiredStringInt32NullableArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt32NullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20058,12 +19839,12 @@ func (c *Client) TestRequestRequiredStringInt32NullableArray(ctx context.Context return result, nil } -// TestRequestRequiredStringInt32NullableArrayArray invokes test_request_required_string_int32_nullable_array_array operation. +// TestRequestRequiredStringDateNullableArrayArray invokes test_request_required_string_date_nullable_array_array operation. // -// POST /test_request_required_string_int32_nullable_array_array -func (c *Client) TestRequestRequiredStringInt32NullableArrayArray(ctx context.Context, request [][]NilStringInt32) (res Error, err error) { +// POST /test_request_required_string_date_nullable_array_array +func (c *Client) TestRequestRequiredStringDateNullableArrayArray(ctx context.Context, request [][]NilDate) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_nullable_array_array"), + otelogen.OperationID("test_request_required_string_date_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -20103,7 +19884,7 @@ func (c *Client) TestRequestRequiredStringInt32NullableArrayArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20120,14 +19901,14 @@ func (c *Client) TestRequestRequiredStringInt32NullableArrayArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int32_nullable_array_array" + u.Path += "/test_request_required_string_date_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt32NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20139,7 +19920,7 @@ func (c *Client) TestRequestRequiredStringInt32NullableArrayArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt32NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20147,12 +19928,12 @@ func (c *Client) TestRequestRequiredStringInt32NullableArrayArray(ctx context.Co return result, nil } -// TestRequestRequiredStringInt64 invokes test_request_required_string_int64 operation. +// TestRequestRequiredStringDateTime invokes test_request_required_string_date-time operation. // -// POST /test_request_required_string_int64 -func (c *Client) TestRequestRequiredStringInt64(ctx context.Context, request int64) (res Error, err error) { +// POST /test_request_required_string_date-time +func (c *Client) TestRequestRequiredStringDateTime(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64"), + otelogen.OperationID("test_request_required_string_date-time"), } // Validate request before sending. @@ -20167,7 +19948,7 @@ func (c *Client) TestRequestRequiredStringInt64(ctx context.Context, request int c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTime", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20184,14 +19965,14 @@ func (c *Client) TestRequestRequiredStringInt64(ctx context.Context, request int stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int64" + u.Path += "/test_request_required_string_date-time" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt64Request(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateTimeRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20203,7 +19984,7 @@ func (c *Client) TestRequestRequiredStringInt64(ctx context.Context, request int defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt64Response(resp, span) + result, err := decodeTestRequestRequiredStringDateTimeResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20211,12 +19992,12 @@ func (c *Client) TestRequestRequiredStringInt64(ctx context.Context, request int return result, nil } -// TestRequestRequiredStringInt64Array invokes test_request_required_string_int64_array operation. +// TestRequestRequiredStringDateTimeArray invokes test_request_required_string_date-time_array operation. // -// POST /test_request_required_string_int64_array -func (c *Client) TestRequestRequiredStringInt64Array(ctx context.Context, request []int64) (res Error, err error) { +// POST /test_request_required_string_date-time_array +func (c *Client) TestRequestRequiredStringDateTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_array"), + otelogen.OperationID("test_request_required_string_date-time_array"), } // Validate request before sending. if err := func() error { @@ -20239,7 +20020,7 @@ func (c *Client) TestRequestRequiredStringInt64Array(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20256,14 +20037,14 @@ func (c *Client) TestRequestRequiredStringInt64Array(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int64_array" + u.Path += "/test_request_required_string_date-time_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt64ArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateTimeArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20275,7 +20056,7 @@ func (c *Client) TestRequestRequiredStringInt64Array(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt64ArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateTimeArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20283,12 +20064,12 @@ func (c *Client) TestRequestRequiredStringInt64Array(ctx context.Context, reques return result, nil } -// TestRequestRequiredStringInt64ArrayArray invokes test_request_required_string_int64_array_array operation. +// TestRequestRequiredStringDateTimeArrayArray invokes test_request_required_string_date-time_array_array operation. // -// POST /test_request_required_string_int64_array_array -func (c *Client) TestRequestRequiredStringInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { +// POST /test_request_required_string_date-time_array_array +func (c *Client) TestRequestRequiredStringDateTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_array_array"), + otelogen.OperationID("test_request_required_string_date-time_array_array"), } // Validate request before sending. if err := func() error { @@ -20328,7 +20109,7 @@ func (c *Client) TestRequestRequiredStringInt64ArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20345,14 +20126,14 @@ func (c *Client) TestRequestRequiredStringInt64ArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int64_array_array" + u.Path += "/test_request_required_string_date-time_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt64ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateTimeArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20364,7 +20145,7 @@ func (c *Client) TestRequestRequiredStringInt64ArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt64ArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateTimeArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20372,12 +20153,12 @@ func (c *Client) TestRequestRequiredStringInt64ArrayArray(ctx context.Context, r return result, nil } -// TestRequestRequiredStringInt64Nullable invokes test_request_required_string_int64_nullable operation. +// TestRequestRequiredStringDateTimeNullable invokes test_request_required_string_date-time_nullable operation. // -// POST /test_request_required_string_int64_nullable -func (c *Client) TestRequestRequiredStringInt64Nullable(ctx context.Context, request NilStringInt64) (res Error, err error) { +// POST /test_request_required_string_date-time_nullable +func (c *Client) TestRequestRequiredStringDateTimeNullable(ctx context.Context, request NilDateTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_nullable"), + otelogen.OperationID("test_request_required_string_date-time_nullable"), } // Validate request before sending. @@ -20392,7 +20173,7 @@ func (c *Client) TestRequestRequiredStringInt64Nullable(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20409,14 +20190,14 @@ func (c *Client) TestRequestRequiredStringInt64Nullable(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int64_nullable" + u.Path += "/test_request_required_string_date-time_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt64NullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateTimeNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20428,7 +20209,7 @@ func (c *Client) TestRequestRequiredStringInt64Nullable(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt64NullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateTimeNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20436,12 +20217,12 @@ func (c *Client) TestRequestRequiredStringInt64Nullable(ctx context.Context, req return result, nil } -// TestRequestRequiredStringInt64NullableArray invokes test_request_required_string_int64_nullable_array operation. +// TestRequestRequiredStringDateTimeNullableArray invokes test_request_required_string_date-time_nullable_array operation. // -// POST /test_request_required_string_int64_nullable_array -func (c *Client) TestRequestRequiredStringInt64NullableArray(ctx context.Context, request []NilStringInt64) (res Error, err error) { +// POST /test_request_required_string_date-time_nullable_array +func (c *Client) TestRequestRequiredStringDateTimeNullableArray(ctx context.Context, request []NilDateTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_nullable_array"), + otelogen.OperationID("test_request_required_string_date-time_nullable_array"), } // Validate request before sending. if err := func() error { @@ -20464,7 +20245,7 @@ func (c *Client) TestRequestRequiredStringInt64NullableArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20481,14 +20262,14 @@ func (c *Client) TestRequestRequiredStringInt64NullableArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int64_nullable_array" + u.Path += "/test_request_required_string_date-time_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt64NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateTimeNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20500,7 +20281,7 @@ func (c *Client) TestRequestRequiredStringInt64NullableArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt64NullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateTimeNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20508,12 +20289,12 @@ func (c *Client) TestRequestRequiredStringInt64NullableArray(ctx context.Context return result, nil } -// TestRequestRequiredStringInt64NullableArrayArray invokes test_request_required_string_int64_nullable_array_array operation. +// TestRequestRequiredStringDateTimeNullableArrayArray invokes test_request_required_string_date-time_nullable_array_array operation. // -// POST /test_request_required_string_int64_nullable_array_array -func (c *Client) TestRequestRequiredStringInt64NullableArrayArray(ctx context.Context, request [][]NilStringInt64) (res Error, err error) { +// POST /test_request_required_string_date-time_nullable_array_array +func (c *Client) TestRequestRequiredStringDateTimeNullableArrayArray(ctx context.Context, request [][]NilDateTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_nullable_array_array"), + otelogen.OperationID("test_request_required_string_date-time_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -20553,7 +20334,7 @@ func (c *Client) TestRequestRequiredStringInt64NullableArrayArray(ctx context.Co c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDateTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20570,14 +20351,14 @@ func (c *Client) TestRequestRequiredStringInt64NullableArrayArray(ctx context.Co stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_int64_nullable_array_array" + u.Path += "/test_request_required_string_date-time_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringInt64NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDateTimeNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20589,7 +20370,7 @@ func (c *Client) TestRequestRequiredStringInt64NullableArrayArray(ctx context.Co defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringInt64NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20597,12 +20378,12 @@ func (c *Client) TestRequestRequiredStringInt64NullableArrayArray(ctx context.Co return result, nil } -// TestRequestRequiredStringIpv4 invokes test_request_required_string_ipv4 operation. +// TestRequestRequiredStringDuration invokes test_request_required_string_duration operation. // -// POST /test_request_required_string_ipv4 -func (c *Client) TestRequestRequiredStringIpv4(ctx context.Context, request netip.Addr) (res Error, err error) { +// POST /test_request_required_string_duration +func (c *Client) TestRequestRequiredStringDuration(ctx context.Context, request time.Duration) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4"), + otelogen.OperationID("test_request_required_string_duration"), } // Validate request before sending. @@ -20617,7 +20398,7 @@ func (c *Client) TestRequestRequiredStringIpv4(ctx context.Context, request neti c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDuration", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20634,14 +20415,14 @@ func (c *Client) TestRequestRequiredStringIpv4(ctx context.Context, request neti stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv4" + u.Path += "/test_request_required_string_duration" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv4Request(request, r); err != nil { + if err := encodeTestRequestRequiredStringDurationRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20653,7 +20434,7 @@ func (c *Client) TestRequestRequiredStringIpv4(ctx context.Context, request neti defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv4Response(resp, span) + result, err := decodeTestRequestRequiredStringDurationResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20661,12 +20442,12 @@ func (c *Client) TestRequestRequiredStringIpv4(ctx context.Context, request neti return result, nil } -// TestRequestRequiredStringIpv4Array invokes test_request_required_string_ipv4_array operation. +// TestRequestRequiredStringDurationArray invokes test_request_required_string_duration_array operation. // -// POST /test_request_required_string_ipv4_array -func (c *Client) TestRequestRequiredStringIpv4Array(ctx context.Context, request []netip.Addr) (res Error, err error) { +// POST /test_request_required_string_duration_array +func (c *Client) TestRequestRequiredStringDurationArray(ctx context.Context, request []time.Duration) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_array"), + otelogen.OperationID("test_request_required_string_duration_array"), } // Validate request before sending. if err := func() error { @@ -20689,7 +20470,7 @@ func (c *Client) TestRequestRequiredStringIpv4Array(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20706,14 +20487,14 @@ func (c *Client) TestRequestRequiredStringIpv4Array(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv4_array" + u.Path += "/test_request_required_string_duration_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv4ArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDurationArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20725,7 +20506,7 @@ func (c *Client) TestRequestRequiredStringIpv4Array(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv4ArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDurationArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20733,12 +20514,12 @@ func (c *Client) TestRequestRequiredStringIpv4Array(ctx context.Context, request return result, nil } -// TestRequestRequiredStringIpv4ArrayArray invokes test_request_required_string_ipv4_array_array operation. +// TestRequestRequiredStringDurationArrayArray invokes test_request_required_string_duration_array_array operation. // -// POST /test_request_required_string_ipv4_array_array -func (c *Client) TestRequestRequiredStringIpv4ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { +// POST /test_request_required_string_duration_array_array +func (c *Client) TestRequestRequiredStringDurationArrayArray(ctx context.Context, request [][]time.Duration) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_array_array"), + otelogen.OperationID("test_request_required_string_duration_array_array"), } // Validate request before sending. if err := func() error { @@ -20778,7 +20559,7 @@ func (c *Client) TestRequestRequiredStringIpv4ArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20795,14 +20576,14 @@ func (c *Client) TestRequestRequiredStringIpv4ArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv4_array_array" + u.Path += "/test_request_required_string_duration_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv4ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDurationArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20814,7 +20595,7 @@ func (c *Client) TestRequestRequiredStringIpv4ArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv4ArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDurationArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20822,12 +20603,12 @@ func (c *Client) TestRequestRequiredStringIpv4ArrayArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringIpv4Nullable invokes test_request_required_string_ipv4_nullable operation. +// TestRequestRequiredStringDurationNullable invokes test_request_required_string_duration_nullable operation. // -// POST /test_request_required_string_ipv4_nullable -func (c *Client) TestRequestRequiredStringIpv4Nullable(ctx context.Context, request NilIPv4) (res Error, err error) { +// POST /test_request_required_string_duration_nullable +func (c *Client) TestRequestRequiredStringDurationNullable(ctx context.Context, request NilDuration) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_nullable"), + otelogen.OperationID("test_request_required_string_duration_nullable"), } // Validate request before sending. @@ -20842,7 +20623,7 @@ func (c *Client) TestRequestRequiredStringIpv4Nullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20859,14 +20640,14 @@ func (c *Client) TestRequestRequiredStringIpv4Nullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv4_nullable" + u.Path += "/test_request_required_string_duration_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv4NullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDurationNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20878,7 +20659,7 @@ func (c *Client) TestRequestRequiredStringIpv4Nullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv4NullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringDurationNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20886,12 +20667,12 @@ func (c *Client) TestRequestRequiredStringIpv4Nullable(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringIpv4NullableArray invokes test_request_required_string_ipv4_nullable_array operation. +// TestRequestRequiredStringDurationNullableArray invokes test_request_required_string_duration_nullable_array operation. // -// POST /test_request_required_string_ipv4_nullable_array -func (c *Client) TestRequestRequiredStringIpv4NullableArray(ctx context.Context, request []NilIPv4) (res Error, err error) { +// POST /test_request_required_string_duration_nullable_array +func (c *Client) TestRequestRequiredStringDurationNullableArray(ctx context.Context, request []NilDuration) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_nullable_array"), + otelogen.OperationID("test_request_required_string_duration_nullable_array"), } // Validate request before sending. if err := func() error { @@ -20914,7 +20695,7 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -20931,14 +20712,14 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv4_nullable_array" + u.Path += "/test_request_required_string_duration_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv4NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDurationNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -20950,7 +20731,7 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv4NullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDurationNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -20958,12 +20739,12 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringIpv4NullableArrayArray invokes test_request_required_string_ipv4_nullable_array_array operation. +// TestRequestRequiredStringDurationNullableArrayArray invokes test_request_required_string_duration_nullable_array_array operation. // -// POST /test_request_required_string_ipv4_nullable_array_array -func (c *Client) TestRequestRequiredStringIpv4NullableArrayArray(ctx context.Context, request [][]NilIPv4) (res Error, err error) { +// POST /test_request_required_string_duration_nullable_array_array +func (c *Client) TestRequestRequiredStringDurationNullableArrayArray(ctx context.Context, request [][]NilDuration) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_nullable_array_array"), + otelogen.OperationID("test_request_required_string_duration_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -21003,7 +20784,7 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringDurationNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21020,14 +20801,14 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv4_nullable_array_array" + u.Path += "/test_request_required_string_duration_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringDurationNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21039,7 +20820,7 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringDurationNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21047,14 +20828,30 @@ func (c *Client) TestRequestRequiredStringIpv4NullableArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredStringIpv6 invokes test_request_required_string_ipv6 operation. +// TestRequestRequiredStringEmail invokes test_request_required_string_email operation. // -// POST /test_request_required_string_ipv6 -func (c *Client) TestRequestRequiredStringIpv6(ctx context.Context, request netip.Addr) (res Error, err error) { +// POST /test_request_required_string_email +func (c *Client) TestRequestRequiredStringEmail(ctx context.Context, request string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6"), + otelogen.OperationID("test_request_required_string_email"), } // Validate request before sending. + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -21067,7 +20864,7 @@ func (c *Client) TestRequestRequiredStringIpv6(ctx context.Context, request neti c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmail", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21084,14 +20881,14 @@ func (c *Client) TestRequestRequiredStringIpv6(ctx context.Context, request neti stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv6" + u.Path += "/test_request_required_string_email" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv6Request(request, r); err != nil { + if err := encodeTestRequestRequiredStringEmailRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21103,7 +20900,7 @@ func (c *Client) TestRequestRequiredStringIpv6(ctx context.Context, request neti defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv6Response(resp, span) + result, err := decodeTestRequestRequiredStringEmailResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21111,18 +20908,43 @@ func (c *Client) TestRequestRequiredStringIpv6(ctx context.Context, request neti return result, nil } -// TestRequestRequiredStringIpv6Array invokes test_request_required_string_ipv6_array operation. +// TestRequestRequiredStringEmailArray invokes test_request_required_string_email_array operation. // -// POST /test_request_required_string_ipv6_array -func (c *Client) TestRequestRequiredStringIpv6Array(ctx context.Context, request []netip.Addr) (res Error, err error) { +// POST /test_request_required_string_email_array +func (c *Client) TestRequestRequiredStringEmailArray(ctx context.Context, request []string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_array"), + otelogen.OperationID("test_request_required_string_email_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -21139,7 +20961,7 @@ func (c *Client) TestRequestRequiredStringIpv6Array(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21156,14 +20978,14 @@ func (c *Client) TestRequestRequiredStringIpv6Array(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv6_array" + u.Path += "/test_request_required_string_email_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv6ArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringEmailArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21175,7 +20997,7 @@ func (c *Client) TestRequestRequiredStringIpv6Array(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv6ArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringEmailArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21183,12 +21005,12 @@ func (c *Client) TestRequestRequiredStringIpv6Array(ctx context.Context, request return result, nil } -// TestRequestRequiredStringIpv6ArrayArray invokes test_request_required_string_ipv6_array_array operation. +// TestRequestRequiredStringEmailArrayArray invokes test_request_required_string_email_array_array operation. // -// POST /test_request_required_string_ipv6_array_array -func (c *Client) TestRequestRequiredStringIpv6ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { +// POST /test_request_required_string_email_array_array +func (c *Client) TestRequestRequiredStringEmailArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_array_array"), + otelogen.OperationID("test_request_required_string_email_array_array"), } // Validate request before sending. if err := func() error { @@ -21201,6 +21023,31 @@ func (c *Client) TestRequestRequiredStringIpv6ArrayArray(ctx context.Context, re if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -21228,7 +21075,7 @@ func (c *Client) TestRequestRequiredStringIpv6ArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21245,14 +21092,14 @@ func (c *Client) TestRequestRequiredStringIpv6ArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv6_array_array" + u.Path += "/test_request_required_string_email_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv6ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringEmailArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21264,7 +21111,7 @@ func (c *Client) TestRequestRequiredStringIpv6ArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv6ArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringEmailArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21272,14 +21119,30 @@ func (c *Client) TestRequestRequiredStringIpv6ArrayArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringIpv6Nullable invokes test_request_required_string_ipv6_nullable operation. +// TestRequestRequiredStringEmailNullable invokes test_request_required_string_email_nullable operation. // -// POST /test_request_required_string_ipv6_nullable -func (c *Client) TestRequestRequiredStringIpv6Nullable(ctx context.Context, request NilIPv6) (res Error, err error) { +// POST /test_request_required_string_email_nullable +func (c *Client) TestRequestRequiredStringEmailNullable(ctx context.Context, request NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_nullable"), + otelogen.OperationID("test_request_required_string_email_nullable"), } // Validate request before sending. + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -21292,7 +21155,7 @@ func (c *Client) TestRequestRequiredStringIpv6Nullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21309,14 +21172,14 @@ func (c *Client) TestRequestRequiredStringIpv6Nullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv6_nullable" + u.Path += "/test_request_required_string_email_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv6NullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringEmailNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21328,7 +21191,7 @@ func (c *Client) TestRequestRequiredStringIpv6Nullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv6NullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringEmailNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21336,18 +21199,43 @@ func (c *Client) TestRequestRequiredStringIpv6Nullable(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringIpv6NullableArray invokes test_request_required_string_ipv6_nullable_array operation. +// TestRequestRequiredStringEmailNullableArray invokes test_request_required_string_email_nullable_array operation. // -// POST /test_request_required_string_ipv6_nullable_array -func (c *Client) TestRequestRequiredStringIpv6NullableArray(ctx context.Context, request []NilIPv6) (res Error, err error) { +// POST /test_request_required_string_email_nullable_array +func (c *Client) TestRequestRequiredStringEmailNullableArray(ctx context.Context, request []NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_nullable_array"), + otelogen.OperationID("test_request_required_string_email_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -21364,7 +21252,7 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21381,14 +21269,14 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv6_nullable_array" + u.Path += "/test_request_required_string_email_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv6NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringEmailNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21400,7 +21288,7 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv6NullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringEmailNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21408,12 +21296,12 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringIpv6NullableArrayArray invokes test_request_required_string_ipv6_nullable_array_array operation. +// TestRequestRequiredStringEmailNullableArrayArray invokes test_request_required_string_email_nullable_array_array operation. // -// POST /test_request_required_string_ipv6_nullable_array_array -func (c *Client) TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Context, request [][]NilIPv6) (res Error, err error) { +// POST /test_request_required_string_email_nullable_array_array +func (c *Client) TestRequestRequiredStringEmailNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_nullable_array_array"), + otelogen.OperationID("test_request_required_string_email_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -21426,6 +21314,31 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Con if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -21453,7 +21366,7 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringEmailNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21470,14 +21383,14 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_ipv6_nullable_array_array" + u.Path += "/test_request_required_string_email_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringEmailNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21489,7 +21402,7 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringEmailNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21497,14 +21410,30 @@ func (c *Client) TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredStringNullable invokes test_request_required_string_nullable operation. +// TestRequestRequiredStringHostname invokes test_request_required_string_hostname operation. // -// POST /test_request_required_string_nullable -func (c *Client) TestRequestRequiredStringNullable(ctx context.Context, request NilString) (res Error, err error) { +// POST /test_request_required_string_hostname +func (c *Client) TestRequestRequiredStringHostname(ctx context.Context, request string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable"), + otelogen.OperationID("test_request_required_string_hostname"), } // Validate request before sending. + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -21517,7 +21446,7 @@ func (c *Client) TestRequestRequiredStringNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostname", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21534,14 +21463,14 @@ func (c *Client) TestRequestRequiredStringNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_nullable" + u.Path += "/test_request_required_string_hostname" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringHostnameRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21553,7 +21482,7 @@ func (c *Client) TestRequestRequiredStringNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringHostnameResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21561,18 +21490,43 @@ func (c *Client) TestRequestRequiredStringNullable(ctx context.Context, request return result, nil } -// TestRequestRequiredStringNullableArray invokes test_request_required_string_nullable_array operation. +// TestRequestRequiredStringHostnameArray invokes test_request_required_string_hostname_array operation. // -// POST /test_request_required_string_nullable_array -func (c *Client) TestRequestRequiredStringNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_required_string_hostname_array +func (c *Client) TestRequestRequiredStringHostnameArray(ctx context.Context, request []string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable_array"), + otelogen.OperationID("test_request_required_string_hostname_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -21589,7 +21543,7 @@ func (c *Client) TestRequestRequiredStringNullableArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21606,14 +21560,14 @@ func (c *Client) TestRequestRequiredStringNullableArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_nullable_array" + u.Path += "/test_request_required_string_hostname_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringHostnameArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21625,7 +21579,7 @@ func (c *Client) TestRequestRequiredStringNullableArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringHostnameArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21633,12 +21587,12 @@ func (c *Client) TestRequestRequiredStringNullableArray(ctx context.Context, req return result, nil } -// TestRequestRequiredStringNullableArrayArray invokes test_request_required_string_nullable_array_array operation. +// TestRequestRequiredStringHostnameArrayArray invokes test_request_required_string_hostname_array_array operation. // -// POST /test_request_required_string_nullable_array_array -func (c *Client) TestRequestRequiredStringNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_required_string_hostname_array_array +func (c *Client) TestRequestRequiredStringHostnameArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable_array_array"), + otelogen.OperationID("test_request_required_string_hostname_array_array"), } // Validate request before sending. if err := func() error { @@ -21651,6 +21605,31 @@ func (c *Client) TestRequestRequiredStringNullableArrayArray(ctx context.Context if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -21678,7 +21657,7 @@ func (c *Client) TestRequestRequiredStringNullableArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21695,14 +21674,14 @@ func (c *Client) TestRequestRequiredStringNullableArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_nullable_array_array" + u.Path += "/test_request_required_string_hostname_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringHostnameArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21714,7 +21693,7 @@ func (c *Client) TestRequestRequiredStringNullableArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringHostnameArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21722,14 +21701,30 @@ func (c *Client) TestRequestRequiredStringNullableArrayArray(ctx context.Context return result, nil } -// TestRequestRequiredStringPassword invokes test_request_required_string_password operation. +// TestRequestRequiredStringHostnameNullable invokes test_request_required_string_hostname_nullable operation. // -// POST /test_request_required_string_password -func (c *Client) TestRequestRequiredStringPassword(ctx context.Context, request string) (res Error, err error) { +// POST /test_request_required_string_hostname_nullable +func (c *Client) TestRequestRequiredStringHostnameNullable(ctx context.Context, request NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password"), + otelogen.OperationID("test_request_required_string_hostname_nullable"), } // Validate request before sending. + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -21742,7 +21737,7 @@ func (c *Client) TestRequestRequiredStringPassword(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPassword", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21759,14 +21754,14 @@ func (c *Client) TestRequestRequiredStringPassword(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_password" + u.Path += "/test_request_required_string_hostname_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringPasswordRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringHostnameNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21778,7 +21773,7 @@ func (c *Client) TestRequestRequiredStringPassword(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringPasswordResponse(resp, span) + result, err := decodeTestRequestRequiredStringHostnameNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21786,18 +21781,43 @@ func (c *Client) TestRequestRequiredStringPassword(ctx context.Context, request return result, nil } -// TestRequestRequiredStringPasswordArray invokes test_request_required_string_password_array operation. +// TestRequestRequiredStringHostnameNullableArray invokes test_request_required_string_hostname_nullable_array operation. // -// POST /test_request_required_string_password_array -func (c *Client) TestRequestRequiredStringPasswordArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_string_hostname_nullable_array +func (c *Client) TestRequestRequiredStringHostnameNullableArray(ctx context.Context, request []NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_array"), + otelogen.OperationID("test_request_required_string_hostname_nullable_array"), } // Validate request before sending. if err := func() error { if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return res, errors.Wrap(err, "validate") @@ -21814,7 +21834,7 @@ func (c *Client) TestRequestRequiredStringPasswordArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21831,14 +21851,14 @@ func (c *Client) TestRequestRequiredStringPasswordArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_password_array" + u.Path += "/test_request_required_string_hostname_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringPasswordArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringHostnameNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21850,7 +21870,7 @@ func (c *Client) TestRequestRequiredStringPasswordArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringPasswordArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringHostnameNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21858,12 +21878,12 @@ func (c *Client) TestRequestRequiredStringPasswordArray(ctx context.Context, req return result, nil } -// TestRequestRequiredStringPasswordArrayArray invokes test_request_required_string_password_array_array operation. +// TestRequestRequiredStringHostnameNullableArrayArray invokes test_request_required_string_hostname_nullable_array_array operation. // -// POST /test_request_required_string_password_array_array -func (c *Client) TestRequestRequiredStringPasswordArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_string_hostname_nullable_array_array +func (c *Client) TestRequestRequiredStringHostnameNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_array_array"), + otelogen.OperationID("test_request_required_string_hostname_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -21876,6 +21896,31 @@ func (c *Client) TestRequestRequiredStringPasswordArrayArray(ctx context.Context if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -21903,7 +21948,7 @@ func (c *Client) TestRequestRequiredStringPasswordArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringHostnameNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21920,14 +21965,14 @@ func (c *Client) TestRequestRequiredStringPasswordArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_password_array_array" + u.Path += "/test_request_required_string_hostname_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringPasswordArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringHostnameNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -21939,7 +21984,7 @@ func (c *Client) TestRequestRequiredStringPasswordArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -21947,12 +21992,12 @@ func (c *Client) TestRequestRequiredStringPasswordArrayArray(ctx context.Context return result, nil } -// TestRequestRequiredStringPasswordNullable invokes test_request_required_string_password_nullable operation. +// TestRequestRequiredStringIP invokes test_request_required_string_ip operation. // -// POST /test_request_required_string_password_nullable -func (c *Client) TestRequestRequiredStringPasswordNullable(ctx context.Context, request NilString) (res Error, err error) { +// POST /test_request_required_string_ip +func (c *Client) TestRequestRequiredStringIP(ctx context.Context, request netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable"), + otelogen.OperationID("test_request_required_string_ip"), } // Validate request before sending. @@ -21967,7 +22012,7 @@ func (c *Client) TestRequestRequiredStringPasswordNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIP", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -21984,14 +22029,14 @@ func (c *Client) TestRequestRequiredStringPasswordNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_password_nullable" + u.Path += "/test_request_required_string_ip" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringPasswordNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIPRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22003,7 +22048,7 @@ func (c *Client) TestRequestRequiredStringPasswordNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringPasswordNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringIPResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22011,12 +22056,12 @@ func (c *Client) TestRequestRequiredStringPasswordNullable(ctx context.Context, return result, nil } -// TestRequestRequiredStringPasswordNullableArray invokes test_request_required_string_password_nullable_array operation. +// TestRequestRequiredStringIPArray invokes test_request_required_string_ip_array operation. // -// POST /test_request_required_string_password_nullable_array -func (c *Client) TestRequestRequiredStringPasswordNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_required_string_ip_array +func (c *Client) TestRequestRequiredStringIPArray(ctx context.Context, request []netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable_array"), + otelogen.OperationID("test_request_required_string_ip_array"), } // Validate request before sending. if err := func() error { @@ -22039,7 +22084,7 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22056,14 +22101,14 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_password_nullable_array" + u.Path += "/test_request_required_string_ip_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringPasswordNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIPArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22075,7 +22120,7 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIPArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22083,12 +22128,12 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArray(ctx context.Cont return result, nil } -// TestRequestRequiredStringPasswordNullableArrayArray invokes test_request_required_string_password_nullable_array_array operation. +// TestRequestRequiredStringIPArrayArray invokes test_request_required_string_ip_array_array operation. // -// POST /test_request_required_string_password_nullable_array_array -func (c *Client) TestRequestRequiredStringPasswordNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_required_string_ip_array_array +func (c *Client) TestRequestRequiredStringIPArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable_array_array"), + otelogen.OperationID("test_request_required_string_ip_array_array"), } // Validate request before sending. if err := func() error { @@ -22128,7 +22173,7 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArrayArray(ctx context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22145,14 +22190,14 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArrayArray(ctx context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_password_nullable_array_array" + u.Path += "/test_request_required_string_ip_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIPArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22164,7 +22209,7 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArrayArray(ctx context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIPArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22172,12 +22217,12 @@ func (c *Client) TestRequestRequiredStringPasswordNullableArrayArray(ctx context return result, nil } -// TestRequestRequiredStringTime invokes test_request_required_string_time operation. +// TestRequestRequiredStringIPNullable invokes test_request_required_string_ip_nullable operation. // -// POST /test_request_required_string_time -func (c *Client) TestRequestRequiredStringTime(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_string_ip_nullable +func (c *Client) TestRequestRequiredStringIPNullable(ctx context.Context, request NilIP) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time"), + otelogen.OperationID("test_request_required_string_ip_nullable"), } // Validate request before sending. @@ -22192,7 +22237,7 @@ func (c *Client) TestRequestRequiredStringTime(ctx context.Context, request time c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTime", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22209,14 +22254,14 @@ func (c *Client) TestRequestRequiredStringTime(ctx context.Context, request time stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_time" + u.Path += "/test_request_required_string_ip_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringTimeRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIPNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22228,7 +22273,7 @@ func (c *Client) TestRequestRequiredStringTime(ctx context.Context, request time defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringTimeResponse(resp, span) + result, err := decodeTestRequestRequiredStringIPNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22236,12 +22281,12 @@ func (c *Client) TestRequestRequiredStringTime(ctx context.Context, request time return result, nil } -// TestRequestRequiredStringTimeArray invokes test_request_required_string_time_array operation. +// TestRequestRequiredStringIPNullableArray invokes test_request_required_string_ip_nullable_array operation. // -// POST /test_request_required_string_time_array -func (c *Client) TestRequestRequiredStringTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_ip_nullable_array +func (c *Client) TestRequestRequiredStringIPNullableArray(ctx context.Context, request []NilIP) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_array"), + otelogen.OperationID("test_request_required_string_ip_nullable_array"), } // Validate request before sending. if err := func() error { @@ -22264,7 +22309,7 @@ func (c *Client) TestRequestRequiredStringTimeArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22281,14 +22326,14 @@ func (c *Client) TestRequestRequiredStringTimeArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_time_array" + u.Path += "/test_request_required_string_ip_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringTimeArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIPNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22300,7 +22345,7 @@ func (c *Client) TestRequestRequiredStringTimeArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringTimeArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIPNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22308,12 +22353,12 @@ func (c *Client) TestRequestRequiredStringTimeArray(ctx context.Context, request return result, nil } -// TestRequestRequiredStringTimeArrayArray invokes test_request_required_string_time_array_array operation. +// TestRequestRequiredStringIPNullableArrayArray invokes test_request_required_string_ip_nullable_array_array operation. // -// POST /test_request_required_string_time_array_array -func (c *Client) TestRequestRequiredStringTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_ip_nullable_array_array +func (c *Client) TestRequestRequiredStringIPNullableArrayArray(ctx context.Context, request [][]NilIP) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_array_array"), + otelogen.OperationID("test_request_required_string_ip_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -22353,7 +22398,7 @@ func (c *Client) TestRequestRequiredStringTimeArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIPNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22370,14 +22415,14 @@ func (c *Client) TestRequestRequiredStringTimeArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_time_array_array" + u.Path += "/test_request_required_string_ip_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringTimeArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIPNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22389,7 +22434,7 @@ func (c *Client) TestRequestRequiredStringTimeArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringTimeArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIPNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22397,12 +22442,12 @@ func (c *Client) TestRequestRequiredStringTimeArrayArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringTimeNullable invokes test_request_required_string_time_nullable operation. +// TestRequestRequiredStringInt32 invokes test_request_required_string_int32 operation. // -// POST /test_request_required_string_time_nullable -func (c *Client) TestRequestRequiredStringTimeNullable(ctx context.Context, request NilTime) (res Error, err error) { +// POST /test_request_required_string_int32 +func (c *Client) TestRequestRequiredStringInt32(ctx context.Context, request int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable"), + otelogen.OperationID("test_request_required_string_int32"), } // Validate request before sending. @@ -22417,7 +22462,7 @@ func (c *Client) TestRequestRequiredStringTimeNullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22434,14 +22479,14 @@ func (c *Client) TestRequestRequiredStringTimeNullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_time_nullable" + u.Path += "/test_request_required_string_int32" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringTimeNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt32Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22453,7 +22498,7 @@ func (c *Client) TestRequestRequiredStringTimeNullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringTimeNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt32Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22461,12 +22506,12 @@ func (c *Client) TestRequestRequiredStringTimeNullable(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringTimeNullableArray invokes test_request_required_string_time_nullable_array operation. +// TestRequestRequiredStringInt32Array invokes test_request_required_string_int32_array operation. // -// POST /test_request_required_string_time_nullable_array -func (c *Client) TestRequestRequiredStringTimeNullableArray(ctx context.Context, request []NilTime) (res Error, err error) { +// POST /test_request_required_string_int32_array +func (c *Client) TestRequestRequiredStringInt32Array(ctx context.Context, request []int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable_array"), + otelogen.OperationID("test_request_required_string_int32_array"), } // Validate request before sending. if err := func() error { @@ -22489,7 +22534,7 @@ func (c *Client) TestRequestRequiredStringTimeNullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22506,14 +22551,14 @@ func (c *Client) TestRequestRequiredStringTimeNullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_time_nullable_array" + u.Path += "/test_request_required_string_int32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringTimeNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22525,7 +22570,7 @@ func (c *Client) TestRequestRequiredStringTimeNullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringTimeNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22533,12 +22578,12 @@ func (c *Client) TestRequestRequiredStringTimeNullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringTimeNullableArrayArray invokes test_request_required_string_time_nullable_array_array operation. +// TestRequestRequiredStringInt32ArrayArray invokes test_request_required_string_int32_array_array operation. // -// POST /test_request_required_string_time_nullable_array_array -func (c *Client) TestRequestRequiredStringTimeNullableArrayArray(ctx context.Context, request [][]NilTime) (res Error, err error) { +// POST /test_request_required_string_int32_array_array +func (c *Client) TestRequestRequiredStringInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable_array_array"), + otelogen.OperationID("test_request_required_string_int32_array_array"), } // Validate request before sending. if err := func() error { @@ -22578,7 +22623,7 @@ func (c *Client) TestRequestRequiredStringTimeNullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22595,14 +22640,14 @@ func (c *Client) TestRequestRequiredStringTimeNullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_time_nullable_array_array" + u.Path += "/test_request_required_string_int32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringTimeNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22614,7 +22659,7 @@ func (c *Client) TestRequestRequiredStringTimeNullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22622,12 +22667,12 @@ func (c *Client) TestRequestRequiredStringTimeNullableArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredStringURI invokes test_request_required_string_uri operation. +// TestRequestRequiredStringInt32Nullable invokes test_request_required_string_int32_nullable operation. // -// POST /test_request_required_string_uri -func (c *Client) TestRequestRequiredStringURI(ctx context.Context, request url.URL) (res Error, err error) { +// POST /test_request_required_string_int32_nullable +func (c *Client) TestRequestRequiredStringInt32Nullable(ctx context.Context, request NilStringInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri"), + otelogen.OperationID("test_request_required_string_int32_nullable"), } // Validate request before sending. @@ -22642,7 +22687,7 @@ func (c *Client) TestRequestRequiredStringURI(ctx context.Context, request url.U c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURI", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22659,14 +22704,14 @@ func (c *Client) TestRequestRequiredStringURI(ctx context.Context, request url.U stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uri" + u.Path += "/test_request_required_string_int32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringURIRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22678,7 +22723,7 @@ func (c *Client) TestRequestRequiredStringURI(ctx context.Context, request url.U defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringURIResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22686,12 +22731,12 @@ func (c *Client) TestRequestRequiredStringURI(ctx context.Context, request url.U return result, nil } -// TestRequestRequiredStringURIArray invokes test_request_required_string_uri_array operation. +// TestRequestRequiredStringInt32NullableArray invokes test_request_required_string_int32_nullable_array operation. // -// POST /test_request_required_string_uri_array -func (c *Client) TestRequestRequiredStringURIArray(ctx context.Context, request []url.URL) (res Error, err error) { +// POST /test_request_required_string_int32_nullable_array +func (c *Client) TestRequestRequiredStringInt32NullableArray(ctx context.Context, request []NilStringInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_array"), + otelogen.OperationID("test_request_required_string_int32_nullable_array"), } // Validate request before sending. if err := func() error { @@ -22714,7 +22759,7 @@ func (c *Client) TestRequestRequiredStringURIArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURIArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22731,14 +22776,14 @@ func (c *Client) TestRequestRequiredStringURIArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uri_array" + u.Path += "/test_request_required_string_int32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringURIArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22750,7 +22795,7 @@ func (c *Client) TestRequestRequiredStringURIArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringURIArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22758,12 +22803,12 @@ func (c *Client) TestRequestRequiredStringURIArray(ctx context.Context, request return result, nil } -// TestRequestRequiredStringURIArrayArray invokes test_request_required_string_uri_array_array operation. +// TestRequestRequiredStringInt32NullableArrayArray invokes test_request_required_string_int32_nullable_array_array operation. // -// POST /test_request_required_string_uri_array_array -func (c *Client) TestRequestRequiredStringURIArrayArray(ctx context.Context, request [][]url.URL) (res Error, err error) { +// POST /test_request_required_string_int32_nullable_array_array +func (c *Client) TestRequestRequiredStringInt32NullableArrayArray(ctx context.Context, request [][]NilStringInt32) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_array_array"), + otelogen.OperationID("test_request_required_string_int32_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -22803,7 +22848,7 @@ func (c *Client) TestRequestRequiredStringURIArrayArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURIArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22820,14 +22865,14 @@ func (c *Client) TestRequestRequiredStringURIArrayArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uri_array_array" + u.Path += "/test_request_required_string_int32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringURIArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22839,7 +22884,7 @@ func (c *Client) TestRequestRequiredStringURIArrayArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringURIArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22847,12 +22892,12 @@ func (c *Client) TestRequestRequiredStringURIArrayArray(ctx context.Context, req return result, nil } -// TestRequestRequiredStringURINullable invokes test_request_required_string_uri_nullable operation. +// TestRequestRequiredStringInt64 invokes test_request_required_string_int64 operation. // -// POST /test_request_required_string_uri_nullable -func (c *Client) TestRequestRequiredStringURINullable(ctx context.Context, request NilURI) (res Error, err error) { +// POST /test_request_required_string_int64 +func (c *Client) TestRequestRequiredStringInt64(ctx context.Context, request int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable"), + otelogen.OperationID("test_request_required_string_int64"), } // Validate request before sending. @@ -22867,7 +22912,7 @@ func (c *Client) TestRequestRequiredStringURINullable(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURINullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22884,14 +22929,14 @@ func (c *Client) TestRequestRequiredStringURINullable(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uri_nullable" + u.Path += "/test_request_required_string_int64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringURINullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22903,7 +22948,7 @@ func (c *Client) TestRequestRequiredStringURINullable(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringURINullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22911,12 +22956,12 @@ func (c *Client) TestRequestRequiredStringURINullable(ctx context.Context, reque return result, nil } -// TestRequestRequiredStringURINullableArray invokes test_request_required_string_uri_nullable_array operation. +// TestRequestRequiredStringInt64Array invokes test_request_required_string_int64_array operation. // -// POST /test_request_required_string_uri_nullable_array -func (c *Client) TestRequestRequiredStringURINullableArray(ctx context.Context, request []NilURI) (res Error, err error) { +// POST /test_request_required_string_int64_array +func (c *Client) TestRequestRequiredStringInt64Array(ctx context.Context, request []int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable_array"), + otelogen.OperationID("test_request_required_string_int64_array"), } // Validate request before sending. if err := func() error { @@ -22939,7 +22984,7 @@ func (c *Client) TestRequestRequiredStringURINullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURINullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -22956,14 +23001,14 @@ func (c *Client) TestRequestRequiredStringURINullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uri_nullable_array" + u.Path += "/test_request_required_string_int64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringURINullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -22975,7 +23020,7 @@ func (c *Client) TestRequestRequiredStringURINullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringURINullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -22983,12 +23028,12 @@ func (c *Client) TestRequestRequiredStringURINullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringURINullableArrayArray invokes test_request_required_string_uri_nullable_array_array operation. +// TestRequestRequiredStringInt64ArrayArray invokes test_request_required_string_int64_array_array operation. // -// POST /test_request_required_string_uri_nullable_array_array -func (c *Client) TestRequestRequiredStringURINullableArrayArray(ctx context.Context, request [][]NilURI) (res Error, err error) { +// POST /test_request_required_string_int64_array_array +func (c *Client) TestRequestRequiredStringInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable_array_array"), + otelogen.OperationID("test_request_required_string_int64_array_array"), } // Validate request before sending. if err := func() error { @@ -23028,7 +23073,7 @@ func (c *Client) TestRequestRequiredStringURINullableArrayArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURINullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23045,14 +23090,14 @@ func (c *Client) TestRequestRequiredStringURINullableArrayArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uri_nullable_array_array" + u.Path += "/test_request_required_string_int64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringURINullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23064,7 +23109,7 @@ func (c *Client) TestRequestRequiredStringURINullableArrayArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23072,12 +23117,12 @@ func (c *Client) TestRequestRequiredStringURINullableArrayArray(ctx context.Cont return result, nil } -// TestRequestRequiredStringUUID invokes test_request_required_string_uuid operation. +// TestRequestRequiredStringInt64Nullable invokes test_request_required_string_int64_nullable operation. // -// POST /test_request_required_string_uuid -func (c *Client) TestRequestRequiredStringUUID(ctx context.Context, request uuid.UUID) (res Error, err error) { +// POST /test_request_required_string_int64_nullable +func (c *Client) TestRequestRequiredStringInt64Nullable(ctx context.Context, request NilStringInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid"), + otelogen.OperationID("test_request_required_string_int64_nullable"), } // Validate request before sending. @@ -23092,7 +23137,7 @@ func (c *Client) TestRequestRequiredStringUUID(ctx context.Context, request uuid c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUID", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23109,14 +23154,14 @@ func (c *Client) TestRequestRequiredStringUUID(ctx context.Context, request uuid stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uuid" + u.Path += "/test_request_required_string_int64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUUIDRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23128,7 +23173,7 @@ func (c *Client) TestRequestRequiredStringUUID(ctx context.Context, request uuid defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUUIDResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23136,12 +23181,12 @@ func (c *Client) TestRequestRequiredStringUUID(ctx context.Context, request uuid return result, nil } -// TestRequestRequiredStringUUIDArray invokes test_request_required_string_uuid_array operation. +// TestRequestRequiredStringInt64NullableArray invokes test_request_required_string_int64_nullable_array operation. // -// POST /test_request_required_string_uuid_array -func (c *Client) TestRequestRequiredStringUUIDArray(ctx context.Context, request []uuid.UUID) (res Error, err error) { +// POST /test_request_required_string_int64_nullable_array +func (c *Client) TestRequestRequiredStringInt64NullableArray(ctx context.Context, request []NilStringInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_array"), + otelogen.OperationID("test_request_required_string_int64_nullable_array"), } // Validate request before sending. if err := func() error { @@ -23164,7 +23209,7 @@ func (c *Client) TestRequestRequiredStringUUIDArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23181,14 +23226,14 @@ func (c *Client) TestRequestRequiredStringUUIDArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uuid_array" + u.Path += "/test_request_required_string_int64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUUIDArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23200,7 +23245,7 @@ func (c *Client) TestRequestRequiredStringUUIDArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUUIDArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23208,12 +23253,12 @@ func (c *Client) TestRequestRequiredStringUUIDArray(ctx context.Context, request return result, nil } -// TestRequestRequiredStringUUIDArrayArray invokes test_request_required_string_uuid_array_array operation. +// TestRequestRequiredStringInt64NullableArrayArray invokes test_request_required_string_int64_nullable_array_array operation. // -// POST /test_request_required_string_uuid_array_array -func (c *Client) TestRequestRequiredStringUUIDArrayArray(ctx context.Context, request [][]uuid.UUID) (res Error, err error) { +// POST /test_request_required_string_int64_nullable_array_array +func (c *Client) TestRequestRequiredStringInt64NullableArrayArray(ctx context.Context, request [][]NilStringInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_array_array"), + otelogen.OperationID("test_request_required_string_int64_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -23253,7 +23298,7 @@ func (c *Client) TestRequestRequiredStringUUIDArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23270,14 +23315,14 @@ func (c *Client) TestRequestRequiredStringUUIDArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uuid_array_array" + u.Path += "/test_request_required_string_int64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUUIDArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringInt64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23289,7 +23334,7 @@ func (c *Client) TestRequestRequiredStringUUIDArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringInt64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23297,12 +23342,12 @@ func (c *Client) TestRequestRequiredStringUUIDArrayArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringUUIDNullable invokes test_request_required_string_uuid_nullable operation. +// TestRequestRequiredStringIpv4 invokes test_request_required_string_ipv4 operation. // -// POST /test_request_required_string_uuid_nullable -func (c *Client) TestRequestRequiredStringUUIDNullable(ctx context.Context, request NilUUID) (res Error, err error) { +// POST /test_request_required_string_ipv4 +func (c *Client) TestRequestRequiredStringIpv4(ctx context.Context, request netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable"), + otelogen.OperationID("test_request_required_string_ipv4"), } // Validate request before sending. @@ -23317,7 +23362,7 @@ func (c *Client) TestRequestRequiredStringUUIDNullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23334,14 +23379,14 @@ func (c *Client) TestRequestRequiredStringUUIDNullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uuid_nullable" + u.Path += "/test_request_required_string_ipv4" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUUIDNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv4Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23353,7 +23398,7 @@ func (c *Client) TestRequestRequiredStringUUIDNullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUUIDNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv4Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23361,12 +23406,12 @@ func (c *Client) TestRequestRequiredStringUUIDNullable(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringUUIDNullableArray invokes test_request_required_string_uuid_nullable_array operation. +// TestRequestRequiredStringIpv4Array invokes test_request_required_string_ipv4_array operation. // -// POST /test_request_required_string_uuid_nullable_array -func (c *Client) TestRequestRequiredStringUUIDNullableArray(ctx context.Context, request []NilUUID) (res Error, err error) { +// POST /test_request_required_string_ipv4_array +func (c *Client) TestRequestRequiredStringIpv4Array(ctx context.Context, request []netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable_array"), + otelogen.OperationID("test_request_required_string_ipv4_array"), } // Validate request before sending. if err := func() error { @@ -23389,7 +23434,7 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23406,14 +23451,14 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uuid_nullable_array" + u.Path += "/test_request_required_string_ipv4_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUUIDNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv4ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23425,7 +23470,7 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv4ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23433,12 +23478,12 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringUUIDNullableArrayArray invokes test_request_required_string_uuid_nullable_array_array operation. +// TestRequestRequiredStringIpv4ArrayArray invokes test_request_required_string_ipv4_array_array operation. // -// POST /test_request_required_string_uuid_nullable_array_array -func (c *Client) TestRequestRequiredStringUUIDNullableArrayArray(ctx context.Context, request [][]NilUUID) (res Error, err error) { +// POST /test_request_required_string_ipv4_array_array +func (c *Client) TestRequestRequiredStringIpv4ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable_array_array"), + otelogen.OperationID("test_request_required_string_ipv4_array_array"), } // Validate request before sending. if err := func() error { @@ -23478,7 +23523,7 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23495,14 +23540,14 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_uuid_nullable_array_array" + u.Path += "/test_request_required_string_ipv4_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv4ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23514,7 +23559,7 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv4ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23522,12 +23567,12 @@ func (c *Client) TestRequestRequiredStringUUIDNullableArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredStringUnix invokes test_request_required_string_unix operation. +// TestRequestRequiredStringIpv4Nullable invokes test_request_required_string_ipv4_nullable operation. // -// POST /test_request_required_string_unix -func (c *Client) TestRequestRequiredStringUnix(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_string_ipv4_nullable +func (c *Client) TestRequestRequiredStringIpv4Nullable(ctx context.Context, request NilIPv4) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix"), + otelogen.OperationID("test_request_required_string_ipv4_nullable"), } // Validate request before sending. @@ -23542,7 +23587,7 @@ func (c *Client) TestRequestRequiredStringUnix(ctx context.Context, request time c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnix", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23559,14 +23604,14 @@ func (c *Client) TestRequestRequiredStringUnix(ctx context.Context, request time stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix" + u.Path += "/test_request_required_string_ipv4_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv4NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23578,7 +23623,7 @@ func (c *Client) TestRequestRequiredStringUnix(ctx context.Context, request time defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv4NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23586,12 +23631,12 @@ func (c *Client) TestRequestRequiredStringUnix(ctx context.Context, request time return result, nil } -// TestRequestRequiredStringUnixArray invokes test_request_required_string_unix_array operation. +// TestRequestRequiredStringIpv4NullableArray invokes test_request_required_string_ipv4_nullable_array operation. // -// POST /test_request_required_string_unix_array -func (c *Client) TestRequestRequiredStringUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_ipv4_nullable_array +func (c *Client) TestRequestRequiredStringIpv4NullableArray(ctx context.Context, request []NilIPv4) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_array"), + otelogen.OperationID("test_request_required_string_ipv4_nullable_array"), } // Validate request before sending. if err := func() error { @@ -23614,7 +23659,7 @@ func (c *Client) TestRequestRequiredStringUnixArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23631,14 +23676,14 @@ func (c *Client) TestRequestRequiredStringUnixArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix_array" + u.Path += "/test_request_required_string_ipv4_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv4NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23650,7 +23695,7 @@ func (c *Client) TestRequestRequiredStringUnixArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv4NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23658,12 +23703,12 @@ func (c *Client) TestRequestRequiredStringUnixArray(ctx context.Context, request return result, nil } -// TestRequestRequiredStringUnixArrayArray invokes test_request_required_string_unix_array_array operation. +// TestRequestRequiredStringIpv4NullableArrayArray invokes test_request_required_string_ipv4_nullable_array_array operation. // -// POST /test_request_required_string_unix_array_array -func (c *Client) TestRequestRequiredStringUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_ipv4_nullable_array_array +func (c *Client) TestRequestRequiredStringIpv4NullableArrayArray(ctx context.Context, request [][]NilIPv4) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_array_array"), + otelogen.OperationID("test_request_required_string_ipv4_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -23703,7 +23748,7 @@ func (c *Client) TestRequestRequiredStringUnixArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv4NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23720,14 +23765,14 @@ func (c *Client) TestRequestRequiredStringUnixArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix_array_array" + u.Path += "/test_request_required_string_ipv4_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23739,7 +23784,7 @@ func (c *Client) TestRequestRequiredStringUnixArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23747,12 +23792,12 @@ func (c *Client) TestRequestRequiredStringUnixArrayArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringUnixMicro invokes test_request_required_string_unix-micro operation. +// TestRequestRequiredStringIpv6 invokes test_request_required_string_ipv6 operation. // -// POST /test_request_required_string_unix-micro -func (c *Client) TestRequestRequiredStringUnixMicro(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_string_ipv6 +func (c *Client) TestRequestRequiredStringIpv6(ctx context.Context, request netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro"), + otelogen.OperationID("test_request_required_string_ipv6"), } // Validate request before sending. @@ -23767,7 +23812,7 @@ func (c *Client) TestRequestRequiredStringUnixMicro(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicro", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23784,14 +23829,14 @@ func (c *Client) TestRequestRequiredStringUnixMicro(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-micro" + u.Path += "/test_request_required_string_ipv6" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMicroRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv6Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23803,7 +23848,7 @@ func (c *Client) TestRequestRequiredStringUnixMicro(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMicroResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv6Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23811,12 +23856,12 @@ func (c *Client) TestRequestRequiredStringUnixMicro(ctx context.Context, request return result, nil } -// TestRequestRequiredStringUnixMicroArray invokes test_request_required_string_unix-micro_array operation. +// TestRequestRequiredStringIpv6Array invokes test_request_required_string_ipv6_array operation. // -// POST /test_request_required_string_unix-micro_array -func (c *Client) TestRequestRequiredStringUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_ipv6_array +func (c *Client) TestRequestRequiredStringIpv6Array(ctx context.Context, request []netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_array"), + otelogen.OperationID("test_request_required_string_ipv6_array"), } // Validate request before sending. if err := func() error { @@ -23839,7 +23884,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23856,14 +23901,14 @@ func (c *Client) TestRequestRequiredStringUnixMicroArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-micro_array" + u.Path += "/test_request_required_string_ipv6_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMicroArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv6ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23875,7 +23920,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMicroArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv6ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23883,12 +23928,12 @@ func (c *Client) TestRequestRequiredStringUnixMicroArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringUnixMicroArrayArray invokes test_request_required_string_unix-micro_array_array operation. +// TestRequestRequiredStringIpv6ArrayArray invokes test_request_required_string_ipv6_array_array operation. // -// POST /test_request_required_string_unix-micro_array_array -func (c *Client) TestRequestRequiredStringUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_ipv6_array_array +func (c *Client) TestRequestRequiredStringIpv6ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_array_array"), + otelogen.OperationID("test_request_required_string_ipv6_array_array"), } // Validate request before sending. if err := func() error { @@ -23928,7 +23973,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -23945,14 +23990,14 @@ func (c *Client) TestRequestRequiredStringUnixMicroArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-micro_array_array" + u.Path += "/test_request_required_string_ipv6_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMicroArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv6ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -23964,7 +24009,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv6ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -23972,12 +24017,12 @@ func (c *Client) TestRequestRequiredStringUnixMicroArrayArray(ctx context.Contex return result, nil } -// TestRequestRequiredStringUnixMicroNullable invokes test_request_required_string_unix-micro_nullable operation. +// TestRequestRequiredStringIpv6Nullable invokes test_request_required_string_ipv6_nullable operation. // -// POST /test_request_required_string_unix-micro_nullable -func (c *Client) TestRequestRequiredStringUnixMicroNullable(ctx context.Context, request NilStringUnixMicro) (res Error, err error) { +// POST /test_request_required_string_ipv6_nullable +func (c *Client) TestRequestRequiredStringIpv6Nullable(ctx context.Context, request NilIPv6) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_nullable"), + otelogen.OperationID("test_request_required_string_ipv6_nullable"), } // Validate request before sending. @@ -23992,7 +24037,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24009,14 +24054,14 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-micro_nullable" + u.Path += "/test_request_required_string_ipv6_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMicroNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv6NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24028,7 +24073,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMicroNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv6NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24036,12 +24081,12 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullable(ctx context.Context, return result, nil } -// TestRequestRequiredStringUnixMicroNullableArray invokes test_request_required_string_unix-micro_nullable_array operation. +// TestRequestRequiredStringIpv6NullableArray invokes test_request_required_string_ipv6_nullable_array operation. // -// POST /test_request_required_string_unix-micro_nullable_array -func (c *Client) TestRequestRequiredStringUnixMicroNullableArray(ctx context.Context, request []NilStringUnixMicro) (res Error, err error) { +// POST /test_request_required_string_ipv6_nullable_array +func (c *Client) TestRequestRequiredStringIpv6NullableArray(ctx context.Context, request []NilIPv6) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_nullable_array"), + otelogen.OperationID("test_request_required_string_ipv6_nullable_array"), } // Validate request before sending. if err := func() error { @@ -24064,7 +24109,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24081,14 +24126,14 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-micro_nullable_array" + u.Path += "/test_request_required_string_ipv6_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMicroNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv6NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24100,7 +24145,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv6NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24108,12 +24153,12 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArray(ctx context.Con return result, nil } -// TestRequestRequiredStringUnixMicroNullableArrayArray invokes test_request_required_string_unix-micro_nullable_array_array operation. +// TestRequestRequiredStringIpv6NullableArrayArray invokes test_request_required_string_ipv6_nullable_array_array operation. // -// POST /test_request_required_string_unix-micro_nullable_array_array -func (c *Client) TestRequestRequiredStringUnixMicroNullableArrayArray(ctx context.Context, request [][]NilStringUnixMicro) (res Error, err error) { +// POST /test_request_required_string_ipv6_nullable_array_array +func (c *Client) TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Context, request [][]NilIPv6) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_required_string_ipv6_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -24153,7 +24198,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArrayArray(ctx contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringIpv6NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24170,14 +24215,14 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArrayArray(ctx contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-micro_nullable_array_array" + u.Path += "/test_request_required_string_ipv6_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24189,7 +24234,7 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArrayArray(ctx contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24197,12 +24242,12 @@ func (c *Client) TestRequestRequiredStringUnixMicroNullableArrayArray(ctx contex return result, nil } -// TestRequestRequiredStringUnixMilli invokes test_request_required_string_unix-milli operation. +// TestRequestRequiredStringNullable invokes test_request_required_string_nullable operation. // -// POST /test_request_required_string_unix-milli -func (c *Client) TestRequestRequiredStringUnixMilli(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_string_nullable +func (c *Client) TestRequestRequiredStringNullable(ctx context.Context, request NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli"), + otelogen.OperationID("test_request_required_string_nullable"), } // Validate request before sending. @@ -24217,7 +24262,7 @@ func (c *Client) TestRequestRequiredStringUnixMilli(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilli", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24234,14 +24279,14 @@ func (c *Client) TestRequestRequiredStringUnixMilli(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-milli" + u.Path += "/test_request_required_string_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMilliRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24253,7 +24298,7 @@ func (c *Client) TestRequestRequiredStringUnixMilli(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMilliResponse(resp, span) + result, err := decodeTestRequestRequiredStringNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24261,12 +24306,12 @@ func (c *Client) TestRequestRequiredStringUnixMilli(ctx context.Context, request return result, nil } -// TestRequestRequiredStringUnixMilliArray invokes test_request_required_string_unix-milli_array operation. +// TestRequestRequiredStringNullableArray invokes test_request_required_string_nullable_array operation. // -// POST /test_request_required_string_unix-milli_array -func (c *Client) TestRequestRequiredStringUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_nullable_array +func (c *Client) TestRequestRequiredStringNullableArray(ctx context.Context, request []NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_array"), + otelogen.OperationID("test_request_required_string_nullable_array"), } // Validate request before sending. if err := func() error { @@ -24289,7 +24334,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24306,14 +24351,14 @@ func (c *Client) TestRequestRequiredStringUnixMilliArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-milli_array" + u.Path += "/test_request_required_string_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMilliArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24325,7 +24370,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMilliArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24333,12 +24378,12 @@ func (c *Client) TestRequestRequiredStringUnixMilliArray(ctx context.Context, re return result, nil } -// TestRequestRequiredStringUnixMilliArrayArray invokes test_request_required_string_unix-milli_array_array operation. +// TestRequestRequiredStringNullableArrayArray invokes test_request_required_string_nullable_array_array operation. // -// POST /test_request_required_string_unix-milli_array_array -func (c *Client) TestRequestRequiredStringUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_nullable_array_array +func (c *Client) TestRequestRequiredStringNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_array_array"), + otelogen.OperationID("test_request_required_string_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -24378,7 +24423,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24395,14 +24440,14 @@ func (c *Client) TestRequestRequiredStringUnixMilliArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-milli_array_array" + u.Path += "/test_request_required_string_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMilliArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24414,7 +24459,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24422,12 +24467,12 @@ func (c *Client) TestRequestRequiredStringUnixMilliArrayArray(ctx context.Contex return result, nil } -// TestRequestRequiredStringUnixMilliNullable invokes test_request_required_string_unix-milli_nullable operation. +// TestRequestRequiredStringPassword invokes test_request_required_string_password operation. // -// POST /test_request_required_string_unix-milli_nullable -func (c *Client) TestRequestRequiredStringUnixMilliNullable(ctx context.Context, request NilStringUnixMilli) (res Error, err error) { +// POST /test_request_required_string_password +func (c *Client) TestRequestRequiredStringPassword(ctx context.Context, request string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_nullable"), + otelogen.OperationID("test_request_required_string_password"), } // Validate request before sending. @@ -24442,7 +24487,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPassword", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24459,14 +24504,14 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-milli_nullable" + u.Path += "/test_request_required_string_password" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMilliNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringPasswordRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24478,7 +24523,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMilliNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringPasswordResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24486,12 +24531,12 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullable(ctx context.Context, return result, nil } -// TestRequestRequiredStringUnixMilliNullableArray invokes test_request_required_string_unix-milli_nullable_array operation. +// TestRequestRequiredStringPasswordArray invokes test_request_required_string_password_array operation. // -// POST /test_request_required_string_unix-milli_nullable_array -func (c *Client) TestRequestRequiredStringUnixMilliNullableArray(ctx context.Context, request []NilStringUnixMilli) (res Error, err error) { +// POST /test_request_required_string_password_array +func (c *Client) TestRequestRequiredStringPasswordArray(ctx context.Context, request []string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_nullable_array"), + otelogen.OperationID("test_request_required_string_password_array"), } // Validate request before sending. if err := func() error { @@ -24514,7 +24559,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24531,14 +24576,14 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-milli_nullable_array" + u.Path += "/test_request_required_string_password_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMilliNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringPasswordArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24550,7 +24595,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringPasswordArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24558,12 +24603,12 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArray(ctx context.Con return result, nil } -// TestRequestRequiredStringUnixMilliNullableArrayArray invokes test_request_required_string_unix-milli_nullable_array_array operation. +// TestRequestRequiredStringPasswordArrayArray invokes test_request_required_string_password_array_array operation. // -// POST /test_request_required_string_unix-milli_nullable_array_array -func (c *Client) TestRequestRequiredStringUnixMilliNullableArrayArray(ctx context.Context, request [][]NilStringUnixMilli) (res Error, err error) { +// POST /test_request_required_string_password_array_array +func (c *Client) TestRequestRequiredStringPasswordArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_required_string_password_array_array"), } // Validate request before sending. if err := func() error { @@ -24603,7 +24648,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArrayArray(ctx contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24620,14 +24665,14 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArrayArray(ctx contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-milli_nullable_array_array" + u.Path += "/test_request_required_string_password_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringPasswordArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24639,7 +24684,7 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArrayArray(ctx contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24647,12 +24692,12 @@ func (c *Client) TestRequestRequiredStringUnixMilliNullableArrayArray(ctx contex return result, nil } -// TestRequestRequiredStringUnixNano invokes test_request_required_string_unix-nano operation. +// TestRequestRequiredStringPasswordNullable invokes test_request_required_string_password_nullable operation. // -// POST /test_request_required_string_unix-nano -func (c *Client) TestRequestRequiredStringUnixNano(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_string_password_nullable +func (c *Client) TestRequestRequiredStringPasswordNullable(ctx context.Context, request NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano"), + otelogen.OperationID("test_request_required_string_password_nullable"), } // Validate request before sending. @@ -24667,7 +24712,7 @@ func (c *Client) TestRequestRequiredStringUnixNano(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNano", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24684,14 +24729,14 @@ func (c *Client) TestRequestRequiredStringUnixNano(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-nano" + u.Path += "/test_request_required_string_password_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNanoRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24703,7 +24748,7 @@ func (c *Client) TestRequestRequiredStringUnixNano(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNanoResponse(resp, span) + result, err := decodeTestRequestRequiredStringPasswordNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24711,12 +24756,12 @@ func (c *Client) TestRequestRequiredStringUnixNano(ctx context.Context, request return result, nil } -// TestRequestRequiredStringUnixNanoArray invokes test_request_required_string_unix-nano_array operation. +// TestRequestRequiredStringPasswordNullableArray invokes test_request_required_string_password_nullable_array operation. // -// POST /test_request_required_string_unix-nano_array -func (c *Client) TestRequestRequiredStringUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_password_nullable_array +func (c *Client) TestRequestRequiredStringPasswordNullableArray(ctx context.Context, request []NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_array"), + otelogen.OperationID("test_request_required_string_password_nullable_array"), } // Validate request before sending. if err := func() error { @@ -24739,7 +24784,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24756,14 +24801,14 @@ func (c *Client) TestRequestRequiredStringUnixNanoArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-nano_array" + u.Path += "/test_request_required_string_password_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNanoArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24775,7 +24820,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNanoArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24783,12 +24828,12 @@ func (c *Client) TestRequestRequiredStringUnixNanoArray(ctx context.Context, req return result, nil } -// TestRequestRequiredStringUnixNanoArrayArray invokes test_request_required_string_unix-nano_array_array operation. +// TestRequestRequiredStringPasswordNullableArrayArray invokes test_request_required_string_password_nullable_array_array operation. // -// POST /test_request_required_string_unix-nano_array_array -func (c *Client) TestRequestRequiredStringUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_password_nullable_array_array +func (c *Client) TestRequestRequiredStringPasswordNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_array_array"), + otelogen.OperationID("test_request_required_string_password_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -24828,7 +24873,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringPasswordNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24845,14 +24890,14 @@ func (c *Client) TestRequestRequiredStringUnixNanoArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-nano_array_array" + u.Path += "/test_request_required_string_password_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNanoArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24864,7 +24909,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24872,12 +24917,12 @@ func (c *Client) TestRequestRequiredStringUnixNanoArrayArray(ctx context.Context return result, nil } -// TestRequestRequiredStringUnixNanoNullable invokes test_request_required_string_unix-nano_nullable operation. +// TestRequestRequiredStringTime invokes test_request_required_string_time operation. // -// POST /test_request_required_string_unix-nano_nullable -func (c *Client) TestRequestRequiredStringUnixNanoNullable(ctx context.Context, request NilStringUnixNano) (res Error, err error) { +// POST /test_request_required_string_time +func (c *Client) TestRequestRequiredStringTime(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_nullable"), + otelogen.OperationID("test_request_required_string_time"), } // Validate request before sending. @@ -24892,7 +24937,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullable(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTime", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24909,14 +24954,14 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullable(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-nano_nullable" + u.Path += "/test_request_required_string_time" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNanoNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringTimeRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -24928,7 +24973,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullable(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNanoNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringTimeResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -24936,12 +24981,12 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullable(ctx context.Context, return result, nil } -// TestRequestRequiredStringUnixNanoNullableArray invokes test_request_required_string_unix-nano_nullable_array operation. +// TestRequestRequiredStringTimeArray invokes test_request_required_string_time_array operation. // -// POST /test_request_required_string_unix-nano_nullable_array -func (c *Client) TestRequestRequiredStringUnixNanoNullableArray(ctx context.Context, request []NilStringUnixNano) (res Error, err error) { +// POST /test_request_required_string_time_array +func (c *Client) TestRequestRequiredStringTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_nullable_array"), + otelogen.OperationID("test_request_required_string_time_array"), } // Validate request before sending. if err := func() error { @@ -24964,7 +25009,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -24981,14 +25026,14 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-nano_nullable_array" + u.Path += "/test_request_required_string_time_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNanoNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringTimeArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25000,7 +25045,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringTimeArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25008,12 +25053,12 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArray(ctx context.Cont return result, nil } -// TestRequestRequiredStringUnixNanoNullableArrayArray invokes test_request_required_string_unix-nano_nullable_array_array operation. +// TestRequestRequiredStringTimeArrayArray invokes test_request_required_string_time_array_array operation. // -// POST /test_request_required_string_unix-nano_nullable_array_array -func (c *Client) TestRequestRequiredStringUnixNanoNullableArrayArray(ctx context.Context, request [][]NilStringUnixNano) (res Error, err error) { +// POST /test_request_required_string_time_array_array +func (c *Client) TestRequestRequiredStringTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_required_string_time_array_array"), } // Validate request before sending. if err := func() error { @@ -25053,7 +25098,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArrayArray(ctx context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25070,14 +25115,14 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArrayArray(ctx context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-nano_nullable_array_array" + u.Path += "/test_request_required_string_time_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringTimeArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25089,7 +25134,7 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArrayArray(ctx context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringTimeArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25097,12 +25142,12 @@ func (c *Client) TestRequestRequiredStringUnixNanoNullableArrayArray(ctx context return result, nil } -// TestRequestRequiredStringUnixNullable invokes test_request_required_string_unix_nullable operation. +// TestRequestRequiredStringTimeNullable invokes test_request_required_string_time_nullable operation. // -// POST /test_request_required_string_unix_nullable -func (c *Client) TestRequestRequiredStringUnixNullable(ctx context.Context, request NilStringUnixSeconds) (res Error, err error) { +// POST /test_request_required_string_time_nullable +func (c *Client) TestRequestRequiredStringTimeNullable(ctx context.Context, request NilTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable"), + otelogen.OperationID("test_request_required_string_time_nullable"), } // Validate request before sending. @@ -25117,7 +25162,7 @@ func (c *Client) TestRequestRequiredStringUnixNullable(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25134,14 +25179,14 @@ func (c *Client) TestRequestRequiredStringUnixNullable(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix_nullable" + u.Path += "/test_request_required_string_time_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25153,7 +25198,7 @@ func (c *Client) TestRequestRequiredStringUnixNullable(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringTimeNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25161,12 +25206,12 @@ func (c *Client) TestRequestRequiredStringUnixNullable(ctx context.Context, requ return result, nil } -// TestRequestRequiredStringUnixNullableArray invokes test_request_required_string_unix_nullable_array operation. +// TestRequestRequiredStringTimeNullableArray invokes test_request_required_string_time_nullable_array operation. // -// POST /test_request_required_string_unix_nullable_array -func (c *Client) TestRequestRequiredStringUnixNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { +// POST /test_request_required_string_time_nullable_array +func (c *Client) TestRequestRequiredStringTimeNullableArray(ctx context.Context, request []NilTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable_array"), + otelogen.OperationID("test_request_required_string_time_nullable_array"), } // Validate request before sending. if err := func() error { @@ -25189,7 +25234,7 @@ func (c *Client) TestRequestRequiredStringUnixNullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25206,14 +25251,14 @@ func (c *Client) TestRequestRequiredStringUnixNullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix_nullable_array" + u.Path += "/test_request_required_string_time_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25225,7 +25270,7 @@ func (c *Client) TestRequestRequiredStringUnixNullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringTimeNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25233,12 +25278,12 @@ func (c *Client) TestRequestRequiredStringUnixNullableArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringUnixNullableArrayArray invokes test_request_required_string_unix_nullable_array_array operation. +// TestRequestRequiredStringTimeNullableArrayArray invokes test_request_required_string_time_nullable_array_array operation. // -// POST /test_request_required_string_unix_nullable_array_array -func (c *Client) TestRequestRequiredStringUnixNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { +// POST /test_request_required_string_time_nullable_array_array +func (c *Client) TestRequestRequiredStringTimeNullableArrayArray(ctx context.Context, request [][]NilTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable_array_array"), + otelogen.OperationID("test_request_required_string_time_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -25278,7 +25323,7 @@ func (c *Client) TestRequestRequiredStringUnixNullableArrayArray(ctx context.Con c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25295,14 +25340,14 @@ func (c *Client) TestRequestRequiredStringUnixNullableArrayArray(ctx context.Con stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix_nullable_array_array" + u.Path += "/test_request_required_string_time_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25314,7 +25359,7 @@ func (c *Client) TestRequestRequiredStringUnixNullableArrayArray(ctx context.Con defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25322,12 +25367,12 @@ func (c *Client) TestRequestRequiredStringUnixNullableArrayArray(ctx context.Con return result, nil } -// TestRequestRequiredStringUnixSeconds invokes test_request_required_string_unix-seconds operation. +// TestRequestRequiredStringURI invokes test_request_required_string_uri operation. // -// POST /test_request_required_string_unix-seconds -func (c *Client) TestRequestRequiredStringUnixSeconds(ctx context.Context, request time.Time) (res Error, err error) { +// POST /test_request_required_string_uri +func (c *Client) TestRequestRequiredStringURI(ctx context.Context, request url.URL) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds"), + otelogen.OperationID("test_request_required_string_uri"), } // Validate request before sending. @@ -25342,7 +25387,7 @@ func (c *Client) TestRequestRequiredStringUnixSeconds(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSeconds", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURI", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25359,14 +25404,14 @@ func (c *Client) TestRequestRequiredStringUnixSeconds(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-seconds" + u.Path += "/test_request_required_string_uri" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixSecondsRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringURIRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25378,7 +25423,7 @@ func (c *Client) TestRequestRequiredStringUnixSeconds(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixSecondsResponse(resp, span) + result, err := decodeTestRequestRequiredStringURIResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25386,12 +25431,12 @@ func (c *Client) TestRequestRequiredStringUnixSeconds(ctx context.Context, reque return result, nil } -// TestRequestRequiredStringUnixSecondsArray invokes test_request_required_string_unix-seconds_array operation. +// TestRequestRequiredStringURIArray invokes test_request_required_string_uri_array operation. // -// POST /test_request_required_string_unix-seconds_array -func (c *Client) TestRequestRequiredStringUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_uri_array +func (c *Client) TestRequestRequiredStringURIArray(ctx context.Context, request []url.URL) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_array"), + otelogen.OperationID("test_request_required_string_uri_array"), } // Validate request before sending. if err := func() error { @@ -25414,7 +25459,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURIArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25431,14 +25476,14 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-seconds_array" + u.Path += "/test_request_required_string_uri_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixSecondsArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringURIArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25450,7 +25495,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringURIArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25458,12 +25503,12 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArray(ctx context.Context, return result, nil } -// TestRequestRequiredStringUnixSecondsArrayArray invokes test_request_required_string_unix-seconds_array_array operation. +// TestRequestRequiredStringURIArrayArray invokes test_request_required_string_uri_array_array operation. // -// POST /test_request_required_string_unix-seconds_array_array -func (c *Client) TestRequestRequiredStringUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_uri_array_array +func (c *Client) TestRequestRequiredStringURIArrayArray(ctx context.Context, request [][]url.URL) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_array_array"), + otelogen.OperationID("test_request_required_string_uri_array_array"), } // Validate request before sending. if err := func() error { @@ -25503,7 +25548,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArrayArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURIArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25520,14 +25565,14 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArrayArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-seconds_array_array" + u.Path += "/test_request_required_string_uri_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringURIArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25539,7 +25584,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArrayArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringURIArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25547,12 +25592,12 @@ func (c *Client) TestRequestRequiredStringUnixSecondsArrayArray(ctx context.Cont return result, nil } -// TestRequestRequiredStringUnixSecondsNullable invokes test_request_required_string_unix-seconds_nullable operation. +// TestRequestRequiredStringURINullable invokes test_request_required_string_uri_nullable operation. // -// POST /test_request_required_string_unix-seconds_nullable -func (c *Client) TestRequestRequiredStringUnixSecondsNullable(ctx context.Context, request NilStringUnixSeconds) (res Error, err error) { +// POST /test_request_required_string_uri_nullable +func (c *Client) TestRequestRequiredStringURINullable(ctx context.Context, request NilURI) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_nullable"), + otelogen.OperationID("test_request_required_string_uri_nullable"), } // Validate request before sending. @@ -25567,7 +25612,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullable(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURINullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25584,14 +25629,14 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullable(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-seconds_nullable" + u.Path += "/test_request_required_string_uri_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixSecondsNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringURINullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25603,7 +25648,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullable(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringURINullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25611,12 +25656,12 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullable(ctx context.Contex return result, nil } -// TestRequestRequiredStringUnixSecondsNullableArray invokes test_request_required_string_unix-seconds_nullable_array operation. +// TestRequestRequiredStringURINullableArray invokes test_request_required_string_uri_nullable_array operation. // -// POST /test_request_required_string_unix-seconds_nullable_array -func (c *Client) TestRequestRequiredStringUnixSecondsNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { +// POST /test_request_required_string_uri_nullable_array +func (c *Client) TestRequestRequiredStringURINullableArray(ctx context.Context, request []NilURI) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_required_string_uri_nullable_array"), } // Validate request before sending. if err := func() error { @@ -25639,7 +25684,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArray(ctx context.C c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURINullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25656,14 +25701,14 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArray(ctx context.C stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-seconds_nullable_array" + u.Path += "/test_request_required_string_uri_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringURINullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25675,7 +25720,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArray(ctx context.C defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringURINullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25683,12 +25728,12 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArray(ctx context.C return result, nil } -// TestRequestRequiredStringUnixSecondsNullableArrayArray invokes test_request_required_string_unix-seconds_nullable_array_array operation. +// TestRequestRequiredStringURINullableArrayArray invokes test_request_required_string_uri_nullable_array_array operation. // -// POST /test_request_required_string_unix-seconds_nullable_array_array -func (c *Client) TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { +// POST /test_request_required_string_uri_nullable_array_array +func (c *Client) TestRequestRequiredStringURINullableArrayArray(ctx context.Context, request [][]NilURI) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uri_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -25728,7 +25773,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringURINullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25745,14 +25790,14 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_required_string_unix-seconds_nullable_array_array" + u.Path += "/test_request_required_string_uri_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringURINullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25764,7 +25809,7 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25772,12 +25817,12 @@ func (c *Client) TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx cont return result, nil } -// TestRequestString invokes test_request_string operation. +// TestRequestRequiredStringUUID invokes test_request_required_string_uuid operation. // -// POST /test_request_string -func (c *Client) TestRequestString(ctx context.Context, request OptString) (res Error, err error) { +// POST /test_request_required_string_uuid +func (c *Client) TestRequestRequiredStringUUID(ctx context.Context, request uuid.UUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string"), + otelogen.OperationID("test_request_required_string_uuid"), } // Validate request before sending. @@ -25792,7 +25837,7 @@ func (c *Client) TestRequestString(ctx context.Context, request OptString) (res c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestString", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUID", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25809,14 +25854,14 @@ func (c *Client) TestRequestString(ctx context.Context, request OptString) (res stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string" + u.Path += "/test_request_required_string_uuid" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUUIDRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25828,7 +25873,7 @@ func (c *Client) TestRequestString(ctx context.Context, request OptString) (res defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringResponse(resp, span) + result, err := decodeTestRequestRequiredStringUUIDResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25836,14 +25881,22 @@ func (c *Client) TestRequestString(ctx context.Context, request OptString) (res return result, nil } -// TestRequestStringArray invokes test_request_string_array operation. +// TestRequestRequiredStringUUIDArray invokes test_request_required_string_uuid_array operation. // -// POST /test_request_string_array -func (c *Client) TestRequestStringArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_string_uuid_array +func (c *Client) TestRequestRequiredStringUUIDArray(ctx context.Context, request []uuid.UUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_array"), + otelogen.OperationID("test_request_required_string_uuid_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -25856,7 +25909,7 @@ func (c *Client) TestRequestStringArray(ctx context.Context, request []string) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25873,14 +25926,14 @@ func (c *Client) TestRequestStringArray(ctx context.Context, request []string) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_array" + u.Path += "/test_request_required_string_uuid_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUUIDArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25892,7 +25945,7 @@ func (c *Client) TestRequestStringArray(ctx context.Context, request []string) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUUIDArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25900,15 +25953,18 @@ func (c *Client) TestRequestStringArray(ctx context.Context, request []string) ( return result, nil } -// TestRequestStringArrayArray invokes test_request_string_array_array operation. +// TestRequestRequiredStringUUIDArrayArray invokes test_request_required_string_uuid_array_array operation. // -// POST /test_request_string_array_array -func (c *Client) TestRequestStringArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_string_uuid_array_array +func (c *Client) TestRequestRequiredStringUUIDArrayArray(ctx context.Context, request [][]uuid.UUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_array_array"), + otelogen.OperationID("test_request_required_string_uuid_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -25942,7 +25998,7 @@ func (c *Client) TestRequestStringArrayArray(ctx context.Context, request [][]st c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -25959,14 +26015,14 @@ func (c *Client) TestRequestStringArrayArray(ctx context.Context, request [][]st stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_array_array" + u.Path += "/test_request_required_string_uuid_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUUIDArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -25978,7 +26034,7 @@ func (c *Client) TestRequestStringArrayArray(ctx context.Context, request [][]st defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -25986,12 +26042,12 @@ func (c *Client) TestRequestStringArrayArray(ctx context.Context, request [][]st return result, nil } -// TestRequestStringBinary invokes test_request_string_binary operation. +// TestRequestRequiredStringUUIDNullable invokes test_request_required_string_uuid_nullable operation. // -// POST /test_request_string_binary -func (c *Client) TestRequestStringBinary(ctx context.Context, request OptString) (res Error, err error) { +// POST /test_request_required_string_uuid_nullable +func (c *Client) TestRequestRequiredStringUUIDNullable(ctx context.Context, request NilUUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary"), + otelogen.OperationID("test_request_required_string_uuid_nullable"), } // Validate request before sending. @@ -26006,7 +26062,7 @@ func (c *Client) TestRequestStringBinary(ctx context.Context, request OptString) c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinary", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26023,14 +26079,14 @@ func (c *Client) TestRequestStringBinary(ctx context.Context, request OptString) stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_binary" + u.Path += "/test_request_required_string_uuid_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringBinaryRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26042,7 +26098,7 @@ func (c *Client) TestRequestStringBinary(ctx context.Context, request OptString) defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringBinaryResponse(resp, span) + result, err := decodeTestRequestRequiredStringUUIDNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26050,14 +26106,22 @@ func (c *Client) TestRequestStringBinary(ctx context.Context, request OptString) return result, nil } -// TestRequestStringBinaryArray invokes test_request_string_binary_array operation. +// TestRequestRequiredStringUUIDNullableArray invokes test_request_required_string_uuid_nullable_array operation. // -// POST /test_request_string_binary_array -func (c *Client) TestRequestStringBinaryArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_string_uuid_nullable_array +func (c *Client) TestRequestRequiredStringUUIDNullableArray(ctx context.Context, request []NilUUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_array"), + otelogen.OperationID("test_request_required_string_uuid_nullable_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -26070,7 +26134,7 @@ func (c *Client) TestRequestStringBinaryArray(ctx context.Context, request []str c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26087,14 +26151,14 @@ func (c *Client) TestRequestStringBinaryArray(ctx context.Context, request []str stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_binary_array" + u.Path += "/test_request_required_string_uuid_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringBinaryArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26106,7 +26170,7 @@ func (c *Client) TestRequestStringBinaryArray(ctx context.Context, request []str defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringBinaryArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26114,15 +26178,18 @@ func (c *Client) TestRequestStringBinaryArray(ctx context.Context, request []str return result, nil } -// TestRequestStringBinaryArrayArray invokes test_request_string_binary_array_array operation. +// TestRequestRequiredStringUUIDNullableArrayArray invokes test_request_required_string_uuid_nullable_array_array operation. // -// POST /test_request_string_binary_array_array -func (c *Client) TestRequestStringBinaryArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_string_uuid_nullable_array_array +func (c *Client) TestRequestRequiredStringUUIDNullableArrayArray(ctx context.Context, request [][]NilUUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_array_array"), + otelogen.OperationID("test_request_required_string_uuid_nullable_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -26156,7 +26223,7 @@ func (c *Client) TestRequestStringBinaryArrayArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUUIDNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26173,14 +26240,14 @@ func (c *Client) TestRequestStringBinaryArrayArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_binary_array_array" + u.Path += "/test_request_required_string_uuid_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringBinaryArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26192,7 +26259,7 @@ func (c *Client) TestRequestStringBinaryArrayArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringBinaryArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26200,12 +26267,12 @@ func (c *Client) TestRequestStringBinaryArrayArray(ctx context.Context, request return result, nil } -// TestRequestStringBinaryNullable invokes test_request_string_binary_nullable operation. +// TestRequestRequiredStringUnix invokes test_request_required_string_unix operation. // -// POST /test_request_string_binary_nullable -func (c *Client) TestRequestStringBinaryNullable(ctx context.Context, request OptNilString) (res Error, err error) { +// POST /test_request_required_string_unix +func (c *Client) TestRequestRequiredStringUnix(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable"), + otelogen.OperationID("test_request_required_string_unix"), } // Validate request before sending. @@ -26220,7 +26287,7 @@ func (c *Client) TestRequestStringBinaryNullable(ctx context.Context, request Op c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnix", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26237,14 +26304,14 @@ func (c *Client) TestRequestStringBinaryNullable(ctx context.Context, request Op stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_binary_nullable" + u.Path += "/test_request_required_string_unix" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringBinaryNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26256,7 +26323,7 @@ func (c *Client) TestRequestStringBinaryNullable(ctx context.Context, request Op defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringBinaryNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26264,14 +26331,22 @@ func (c *Client) TestRequestStringBinaryNullable(ctx context.Context, request Op return result, nil } -// TestRequestStringBinaryNullableArray invokes test_request_string_binary_nullable_array operation. +// TestRequestRequiredStringUnixArray invokes test_request_required_string_unix_array operation. // -// POST /test_request_string_binary_nullable_array -func (c *Client) TestRequestStringBinaryNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_required_string_unix_array +func (c *Client) TestRequestRequiredStringUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable_array"), + otelogen.OperationID("test_request_required_string_unix_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -26284,7 +26359,7 @@ func (c *Client) TestRequestStringBinaryNullableArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26301,14 +26376,14 @@ func (c *Client) TestRequestStringBinaryNullableArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_binary_nullable_array" + u.Path += "/test_request_required_string_unix_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringBinaryNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26320,7 +26395,7 @@ func (c *Client) TestRequestStringBinaryNullableArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringBinaryNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26328,15 +26403,18 @@ func (c *Client) TestRequestStringBinaryNullableArray(ctx context.Context, reque return result, nil } -// TestRequestStringBinaryNullableArrayArray invokes test_request_string_binary_nullable_array_array operation. +// TestRequestRequiredStringUnixArrayArray invokes test_request_required_string_unix_array_array operation. // -// POST /test_request_string_binary_nullable_array_array -func (c *Client) TestRequestStringBinaryNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_required_string_unix_array_array +func (c *Client) TestRequestRequiredStringUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -26370,7 +26448,7 @@ func (c *Client) TestRequestStringBinaryNullableArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26387,14 +26465,14 @@ func (c *Client) TestRequestStringBinaryNullableArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_binary_nullable_array_array" + u.Path += "/test_request_required_string_unix_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringBinaryNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26406,7 +26484,7 @@ func (c *Client) TestRequestStringBinaryNullableArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringBinaryNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26414,12 +26492,12 @@ func (c *Client) TestRequestStringBinaryNullableArrayArray(ctx context.Context, return result, nil } -// TestRequestStringByte invokes test_request_string_byte operation. +// TestRequestRequiredStringUnixMicro invokes test_request_required_string_unix-micro operation. // -// POST /test_request_string_byte -func (c *Client) TestRequestStringByte(ctx context.Context, request []byte) (res Error, err error) { +// POST /test_request_required_string_unix-micro +func (c *Client) TestRequestRequiredStringUnixMicro(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte"), + otelogen.OperationID("test_request_required_string_unix-micro"), } // Validate request before sending. @@ -26434,7 +26512,7 @@ func (c *Client) TestRequestStringByte(ctx context.Context, request []byte) (res c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByte", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicro", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26451,14 +26529,14 @@ func (c *Client) TestRequestStringByte(ctx context.Context, request []byte) (res stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_byte" + u.Path += "/test_request_required_string_unix-micro" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringByteRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26470,7 +26548,7 @@ func (c *Client) TestRequestStringByte(ctx context.Context, request []byte) (res defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringByteResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMicroResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26478,14 +26556,22 @@ func (c *Client) TestRequestStringByte(ctx context.Context, request []byte) (res return result, nil } -// TestRequestStringByteArray invokes test_request_string_byte_array operation. +// TestRequestRequiredStringUnixMicroArray invokes test_request_required_string_unix-micro_array operation. // -// POST /test_request_string_byte_array -func (c *Client) TestRequestStringByteArray(ctx context.Context, request [][]byte) (res Error, err error) { +// POST /test_request_required_string_unix-micro_array +func (c *Client) TestRequestRequiredStringUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_array"), + otelogen.OperationID("test_request_required_string_unix-micro_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -26498,7 +26584,7 @@ func (c *Client) TestRequestStringByteArray(ctx context.Context, request [][]byt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26515,14 +26601,14 @@ func (c *Client) TestRequestStringByteArray(ctx context.Context, request [][]byt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_byte_array" + u.Path += "/test_request_required_string_unix-micro_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringByteArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26534,7 +26620,7 @@ func (c *Client) TestRequestStringByteArray(ctx context.Context, request [][]byt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringByteArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMicroArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26542,15 +26628,18 @@ func (c *Client) TestRequestStringByteArray(ctx context.Context, request [][]byt return result, nil } -// TestRequestStringByteArrayArray invokes test_request_string_byte_array_array operation. +// TestRequestRequiredStringUnixMicroArrayArray invokes test_request_required_string_unix-micro_array_array operation. // -// POST /test_request_string_byte_array_array -func (c *Client) TestRequestStringByteArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { +// POST /test_request_required_string_unix-micro_array_array +func (c *Client) TestRequestRequiredStringUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_array_array"), + otelogen.OperationID("test_request_required_string_unix-micro_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -26584,7 +26673,7 @@ func (c *Client) TestRequestStringByteArrayArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26601,14 +26690,14 @@ func (c *Client) TestRequestStringByteArrayArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_byte_array_array" + u.Path += "/test_request_required_string_unix-micro_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringByteArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26620,7 +26709,7 @@ func (c *Client) TestRequestStringByteArrayArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringByteArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26628,12 +26717,12 @@ func (c *Client) TestRequestStringByteArrayArray(ctx context.Context, request [] return result, nil } -// TestRequestStringByteNullable invokes test_request_string_byte_nullable operation. +// TestRequestRequiredStringUnixMicroNullable invokes test_request_required_string_unix-micro_nullable operation. // -// POST /test_request_string_byte_nullable -func (c *Client) TestRequestStringByteNullable(ctx context.Context, request OptNilByte) (res Error, err error) { +// POST /test_request_required_string_unix-micro_nullable +func (c *Client) TestRequestRequiredStringUnixMicroNullable(ctx context.Context, request NilStringUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable"), + otelogen.OperationID("test_request_required_string_unix-micro_nullable"), } // Validate request before sending. @@ -26648,7 +26737,7 @@ func (c *Client) TestRequestStringByteNullable(ctx context.Context, request OptN c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26665,14 +26754,14 @@ func (c *Client) TestRequestStringByteNullable(ctx context.Context, request OptN stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_byte_nullable" + u.Path += "/test_request_required_string_unix-micro_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringByteNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26684,7 +26773,7 @@ func (c *Client) TestRequestStringByteNullable(ctx context.Context, request OptN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringByteNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMicroNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26692,14 +26781,22 @@ func (c *Client) TestRequestStringByteNullable(ctx context.Context, request OptN return result, nil } -// TestRequestStringByteNullableArray invokes test_request_string_byte_nullable_array operation. +// TestRequestRequiredStringUnixMicroNullableArray invokes test_request_required_string_unix-micro_nullable_array operation. // -// POST /test_request_string_byte_nullable_array -func (c *Client) TestRequestStringByteNullableArray(ctx context.Context, request [][]byte) (res Error, err error) { +// POST /test_request_required_string_unix-micro_nullable_array +func (c *Client) TestRequestRequiredStringUnixMicroNullableArray(ctx context.Context, request []NilStringUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-micro_nullable_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -26712,7 +26809,7 @@ func (c *Client) TestRequestStringByteNullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26729,14 +26826,14 @@ func (c *Client) TestRequestStringByteNullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_byte_nullable_array" + u.Path += "/test_request_required_string_unix-micro_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringByteNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26748,7 +26845,7 @@ func (c *Client) TestRequestStringByteNullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringByteNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26756,15 +26853,18 @@ func (c *Client) TestRequestStringByteNullableArray(ctx context.Context, request return result, nil } -// TestRequestStringByteNullableArrayArray invokes test_request_string_byte_nullable_array_array operation. +// TestRequestRequiredStringUnixMicroNullableArrayArray invokes test_request_required_string_unix-micro_nullable_array_array operation. // -// POST /test_request_string_byte_nullable_array_array -func (c *Client) TestRequestStringByteNullableArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { +// POST /test_request_required_string_unix-micro_nullable_array_array +func (c *Client) TestRequestRequiredStringUnixMicroNullableArrayArray(ctx context.Context, request [][]NilStringUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-micro_nullable_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -26798,7 +26898,7 @@ func (c *Client) TestRequestStringByteNullableArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26815,14 +26915,14 @@ func (c *Client) TestRequestStringByteNullableArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_byte_nullable_array_array" + u.Path += "/test_request_required_string_unix-micro_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringByteNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26834,7 +26934,7 @@ func (c *Client) TestRequestStringByteNullableArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringByteNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26842,12 +26942,12 @@ func (c *Client) TestRequestStringByteNullableArrayArray(ctx context.Context, re return result, nil } -// TestRequestStringDate invokes test_request_string_date operation. +// TestRequestRequiredStringUnixMilli invokes test_request_required_string_unix-milli operation. // -// POST /test_request_string_date -func (c *Client) TestRequestStringDate(ctx context.Context, request OptDate) (res Error, err error) { +// POST /test_request_required_string_unix-milli +func (c *Client) TestRequestRequiredStringUnixMilli(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date"), + otelogen.OperationID("test_request_required_string_unix-milli"), } // Validate request before sending. @@ -26862,7 +26962,7 @@ func (c *Client) TestRequestStringDate(ctx context.Context, request OptDate) (re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDate", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilli", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26879,14 +26979,14 @@ func (c *Client) TestRequestStringDate(ctx context.Context, request OptDate) (re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date" + u.Path += "/test_request_required_string_unix-milli" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26898,7 +26998,7 @@ func (c *Client) TestRequestStringDate(ctx context.Context, request OptDate) (re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMilliResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26906,14 +27006,22 @@ func (c *Client) TestRequestStringDate(ctx context.Context, request OptDate) (re return result, nil } -// TestRequestStringDateArray invokes test_request_string_date_array operation. +// TestRequestRequiredStringUnixMilliArray invokes test_request_required_string_unix-milli_array operation. // -// POST /test_request_string_date_array -func (c *Client) TestRequestStringDateArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_unix-milli_array +func (c *Client) TestRequestRequiredStringUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_array"), + otelogen.OperationID("test_request_required_string_unix-milli_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -26926,7 +27034,7 @@ func (c *Client) TestRequestStringDateArray(ctx context.Context, request []time. c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -26943,14 +27051,14 @@ func (c *Client) TestRequestStringDateArray(ctx context.Context, request []time. stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date_array" + u.Path += "/test_request_required_string_unix-milli_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -26962,7 +27070,7 @@ func (c *Client) TestRequestStringDateArray(ctx context.Context, request []time. defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMilliArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -26970,15 +27078,18 @@ func (c *Client) TestRequestStringDateArray(ctx context.Context, request []time. return result, nil } -// TestRequestStringDateArrayArray invokes test_request_string_date_array_array operation. +// TestRequestRequiredStringUnixMilliArrayArray invokes test_request_required_string_unix-milli_array_array operation. // -// POST /test_request_string_date_array_array -func (c *Client) TestRequestStringDateArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_unix-milli_array_array +func (c *Client) TestRequestRequiredStringUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_array_array"), + otelogen.OperationID("test_request_required_string_unix-milli_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -27012,7 +27123,7 @@ func (c *Client) TestRequestStringDateArrayArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27029,14 +27140,14 @@ func (c *Client) TestRequestStringDateArrayArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date_array_array" + u.Path += "/test_request_required_string_unix-milli_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27048,7 +27159,7 @@ func (c *Client) TestRequestStringDateArrayArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27056,12 +27167,12 @@ func (c *Client) TestRequestStringDateArrayArray(ctx context.Context, request [] return result, nil } -// TestRequestStringDateNullable invokes test_request_string_date_nullable operation. +// TestRequestRequiredStringUnixMilliNullable invokes test_request_required_string_unix-milli_nullable operation. // -// POST /test_request_string_date_nullable -func (c *Client) TestRequestStringDateNullable(ctx context.Context, request OptNilDate) (res Error, err error) { +// POST /test_request_required_string_unix-milli_nullable +func (c *Client) TestRequestRequiredStringUnixMilliNullable(ctx context.Context, request NilStringUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable"), + otelogen.OperationID("test_request_required_string_unix-milli_nullable"), } // Validate request before sending. @@ -27076,7 +27187,7 @@ func (c *Client) TestRequestStringDateNullable(ctx context.Context, request OptN c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27093,14 +27204,14 @@ func (c *Client) TestRequestStringDateNullable(ctx context.Context, request OptN stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date_nullable" + u.Path += "/test_request_required_string_unix-milli_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27112,7 +27223,7 @@ func (c *Client) TestRequestStringDateNullable(ctx context.Context, request OptN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMilliNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27120,14 +27231,22 @@ func (c *Client) TestRequestStringDateNullable(ctx context.Context, request OptN return result, nil } -// TestRequestStringDateNullableArray invokes test_request_string_date_nullable_array operation. +// TestRequestRequiredStringUnixMilliNullableArray invokes test_request_required_string_unix-milli_nullable_array operation. // -// POST /test_request_string_date_nullable_array -func (c *Client) TestRequestStringDateNullableArray(ctx context.Context, request []NilDate) (res Error, err error) { +// POST /test_request_required_string_unix-milli_nullable_array +func (c *Client) TestRequestRequiredStringUnixMilliNullableArray(ctx context.Context, request []NilStringUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-milli_nullable_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -27140,7 +27259,7 @@ func (c *Client) TestRequestStringDateNullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27157,14 +27276,14 @@ func (c *Client) TestRequestStringDateNullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date_nullable_array" + u.Path += "/test_request_required_string_unix-milli_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27176,7 +27295,7 @@ func (c *Client) TestRequestStringDateNullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27184,15 +27303,18 @@ func (c *Client) TestRequestStringDateNullableArray(ctx context.Context, request return result, nil } -// TestRequestStringDateNullableArrayArray invokes test_request_string_date_nullable_array_array operation. +// TestRequestRequiredStringUnixMilliNullableArrayArray invokes test_request_required_string_unix-milli_nullable_array_array operation. // -// POST /test_request_string_date_nullable_array_array -func (c *Client) TestRequestStringDateNullableArrayArray(ctx context.Context, request [][]NilDate) (res Error, err error) { +// POST /test_request_required_string_unix-milli_nullable_array_array +func (c *Client) TestRequestRequiredStringUnixMilliNullableArrayArray(ctx context.Context, request [][]NilStringUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-milli_nullable_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -27226,7 +27348,7 @@ func (c *Client) TestRequestStringDateNullableArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27243,14 +27365,14 @@ func (c *Client) TestRequestStringDateNullableArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date_nullable_array_array" + u.Path += "/test_request_required_string_unix-milli_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27262,7 +27384,7 @@ func (c *Client) TestRequestStringDateNullableArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27270,12 +27392,12 @@ func (c *Client) TestRequestStringDateNullableArrayArray(ctx context.Context, re return result, nil } -// TestRequestStringDateTime invokes test_request_string_date-time operation. +// TestRequestRequiredStringUnixNano invokes test_request_required_string_unix-nano operation. // -// POST /test_request_string_date-time -func (c *Client) TestRequestStringDateTime(ctx context.Context, request OptDateTime) (res Error, err error) { +// POST /test_request_required_string_unix-nano +func (c *Client) TestRequestRequiredStringUnixNano(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time"), + otelogen.OperationID("test_request_required_string_unix-nano"), } // Validate request before sending. @@ -27290,7 +27412,7 @@ func (c *Client) TestRequestStringDateTime(ctx context.Context, request OptDateT c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTime", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNano", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27307,14 +27429,14 @@ func (c *Client) TestRequestStringDateTime(ctx context.Context, request OptDateT stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date-time" + u.Path += "/test_request_required_string_unix-nano" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateTimeRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27326,7 +27448,7 @@ func (c *Client) TestRequestStringDateTime(ctx context.Context, request OptDateT defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateTimeResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNanoResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27334,14 +27456,22 @@ func (c *Client) TestRequestStringDateTime(ctx context.Context, request OptDateT return result, nil } -// TestRequestStringDateTimeArray invokes test_request_string_date-time_array operation. +// TestRequestRequiredStringUnixNanoArray invokes test_request_required_string_unix-nano_array operation. // -// POST /test_request_string_date-time_array -func (c *Client) TestRequestStringDateTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_required_string_unix-nano_array +func (c *Client) TestRequestRequiredStringUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_array"), + otelogen.OperationID("test_request_required_string_unix-nano_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -27354,7 +27484,7 @@ func (c *Client) TestRequestStringDateTimeArray(ctx context.Context, request []t c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27371,14 +27501,14 @@ func (c *Client) TestRequestStringDateTimeArray(ctx context.Context, request []t stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date-time_array" + u.Path += "/test_request_required_string_unix-nano_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateTimeArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27390,7 +27520,7 @@ func (c *Client) TestRequestStringDateTimeArray(ctx context.Context, request []t defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateTimeArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNanoArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27398,15 +27528,18 @@ func (c *Client) TestRequestStringDateTimeArray(ctx context.Context, request []t return result, nil } -// TestRequestStringDateTimeArrayArray invokes test_request_string_date-time_array_array operation. +// TestRequestRequiredStringUnixNanoArrayArray invokes test_request_required_string_unix-nano_array_array operation. // -// POST /test_request_string_date-time_array_array -func (c *Client) TestRequestStringDateTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_required_string_unix-nano_array_array +func (c *Client) TestRequestRequiredStringUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_array_array"), + otelogen.OperationID("test_request_required_string_unix-nano_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -27440,7 +27573,7 @@ func (c *Client) TestRequestStringDateTimeArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27457,14 +27590,14 @@ func (c *Client) TestRequestStringDateTimeArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date-time_array_array" + u.Path += "/test_request_required_string_unix-nano_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateTimeArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27476,7 +27609,7 @@ func (c *Client) TestRequestStringDateTimeArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateTimeArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27484,12 +27617,12 @@ func (c *Client) TestRequestStringDateTimeArrayArray(ctx context.Context, reques return result, nil } -// TestRequestStringDateTimeNullable invokes test_request_string_date-time_nullable operation. +// TestRequestRequiredStringUnixNanoNullable invokes test_request_required_string_unix-nano_nullable operation. // -// POST /test_request_string_date-time_nullable -func (c *Client) TestRequestStringDateTimeNullable(ctx context.Context, request OptNilDateTime) (res Error, err error) { +// POST /test_request_required_string_unix-nano_nullable +func (c *Client) TestRequestRequiredStringUnixNanoNullable(ctx context.Context, request NilStringUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable"), } // Validate request before sending. @@ -27504,7 +27637,7 @@ func (c *Client) TestRequestStringDateTimeNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27521,14 +27654,14 @@ func (c *Client) TestRequestStringDateTimeNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date-time_nullable" + u.Path += "/test_request_required_string_unix-nano_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateTimeNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27540,7 +27673,7 @@ func (c *Client) TestRequestStringDateTimeNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateTimeNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNanoNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27548,14 +27681,22 @@ func (c *Client) TestRequestStringDateTimeNullable(ctx context.Context, request return result, nil } -// TestRequestStringDateTimeNullableArray invokes test_request_string_date-time_nullable_array operation. +// TestRequestRequiredStringUnixNanoNullableArray invokes test_request_required_string_unix-nano_nullable_array operation. // -// POST /test_request_string_date-time_nullable_array -func (c *Client) TestRequestStringDateTimeNullableArray(ctx context.Context, request []NilDateTime) (res Error, err error) { +// POST /test_request_required_string_unix-nano_nullable_array +func (c *Client) TestRequestRequiredStringUnixNanoNullableArray(ctx context.Context, request []NilStringUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -27568,7 +27709,7 @@ func (c *Client) TestRequestStringDateTimeNullableArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27585,14 +27726,14 @@ func (c *Client) TestRequestStringDateTimeNullableArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date-time_nullable_array" + u.Path += "/test_request_required_string_unix-nano_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateTimeNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27604,7 +27745,7 @@ func (c *Client) TestRequestStringDateTimeNullableArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateTimeNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27612,15 +27753,18 @@ func (c *Client) TestRequestStringDateTimeNullableArray(ctx context.Context, req return result, nil } -// TestRequestStringDateTimeNullableArrayArray invokes test_request_string_date-time_nullable_array_array operation. +// TestRequestRequiredStringUnixNanoNullableArrayArray invokes test_request_required_string_unix-nano_nullable_array_array operation. // -// POST /test_request_string_date-time_nullable_array_array -func (c *Client) TestRequestStringDateTimeNullableArrayArray(ctx context.Context, request [][]NilDateTime) (res Error, err error) { +// POST /test_request_required_string_unix-nano_nullable_array_array +func (c *Client) TestRequestRequiredStringUnixNanoNullableArrayArray(ctx context.Context, request [][]NilStringUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -27654,7 +27798,7 @@ func (c *Client) TestRequestStringDateTimeNullableArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27671,14 +27815,14 @@ func (c *Client) TestRequestStringDateTimeNullableArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_date-time_nullable_array_array" + u.Path += "/test_request_required_string_unix-nano_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDateTimeNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27690,7 +27834,7 @@ func (c *Client) TestRequestStringDateTimeNullableArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDateTimeNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27698,12 +27842,12 @@ func (c *Client) TestRequestStringDateTimeNullableArrayArray(ctx context.Context return result, nil } -// TestRequestStringDuration invokes test_request_string_duration operation. +// TestRequestRequiredStringUnixNullable invokes test_request_required_string_unix_nullable operation. // -// POST /test_request_string_duration -func (c *Client) TestRequestStringDuration(ctx context.Context, request OptDuration) (res Error, err error) { +// POST /test_request_required_string_unix_nullable +func (c *Client) TestRequestRequiredStringUnixNullable(ctx context.Context, request NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration"), + otelogen.OperationID("test_request_required_string_unix_nullable"), } // Validate request before sending. @@ -27718,7 +27862,7 @@ func (c *Client) TestRequestStringDuration(ctx context.Context, request OptDurat c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDuration", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27735,14 +27879,14 @@ func (c *Client) TestRequestStringDuration(ctx context.Context, request OptDurat stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_duration" + u.Path += "/test_request_required_string_unix_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDurationRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27754,7 +27898,7 @@ func (c *Client) TestRequestStringDuration(ctx context.Context, request OptDurat defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDurationResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27762,14 +27906,22 @@ func (c *Client) TestRequestStringDuration(ctx context.Context, request OptDurat return result, nil } -// TestRequestStringDurationArray invokes test_request_string_duration_array operation. +// TestRequestRequiredStringUnixNullableArray invokes test_request_required_string_unix_nullable_array operation. // -// POST /test_request_string_duration_array -func (c *Client) TestRequestStringDurationArray(ctx context.Context, request []time.Duration) (res Error, err error) { +// POST /test_request_required_string_unix_nullable_array +func (c *Client) TestRequestRequiredStringUnixNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_array"), + otelogen.OperationID("test_request_required_string_unix_nullable_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -27782,7 +27934,7 @@ func (c *Client) TestRequestStringDurationArray(ctx context.Context, request []t c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27799,14 +27951,14 @@ func (c *Client) TestRequestStringDurationArray(ctx context.Context, request []t stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_duration_array" + u.Path += "/test_request_required_string_unix_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDurationArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27818,7 +27970,7 @@ func (c *Client) TestRequestStringDurationArray(ctx context.Context, request []t defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDurationArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27826,15 +27978,18 @@ func (c *Client) TestRequestStringDurationArray(ctx context.Context, request []t return result, nil } -// TestRequestStringDurationArrayArray invokes test_request_string_duration_array_array operation. +// TestRequestRequiredStringUnixNullableArrayArray invokes test_request_required_string_unix_nullable_array_array operation. // -// POST /test_request_string_duration_array_array -func (c *Client) TestRequestStringDurationArrayArray(ctx context.Context, request [][]time.Duration) (res Error, err error) { +// POST /test_request_required_string_unix_nullable_array_array +func (c *Client) TestRequestRequiredStringUnixNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_array_array"), + otelogen.OperationID("test_request_required_string_unix_nullable_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -27868,7 +28023,7 @@ func (c *Client) TestRequestStringDurationArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27885,14 +28040,14 @@ func (c *Client) TestRequestStringDurationArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_duration_array_array" + u.Path += "/test_request_required_string_unix_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDurationArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27904,7 +28059,7 @@ func (c *Client) TestRequestStringDurationArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDurationArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27912,12 +28067,12 @@ func (c *Client) TestRequestStringDurationArrayArray(ctx context.Context, reques return result, nil } -// TestRequestStringDurationNullable invokes test_request_string_duration_nullable operation. +// TestRequestRequiredStringUnixSeconds invokes test_request_required_string_unix-seconds operation. // -// POST /test_request_string_duration_nullable -func (c *Client) TestRequestStringDurationNullable(ctx context.Context, request OptNilDuration) (res Error, err error) { +// POST /test_request_required_string_unix-seconds +func (c *Client) TestRequestRequiredStringUnixSeconds(ctx context.Context, request time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable"), + otelogen.OperationID("test_request_required_string_unix-seconds"), } // Validate request before sending. @@ -27932,7 +28087,7 @@ func (c *Client) TestRequestStringDurationNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSeconds", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -27949,14 +28104,14 @@ func (c *Client) TestRequestStringDurationNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_duration_nullable" + u.Path += "/test_request_required_string_unix-seconds" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDurationNullableRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -27968,7 +28123,7 @@ func (c *Client) TestRequestStringDurationNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDurationNullableResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixSecondsResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -27976,14 +28131,22 @@ func (c *Client) TestRequestStringDurationNullable(ctx context.Context, request return result, nil } -// TestRequestStringDurationNullableArray invokes test_request_string_duration_nullable_array operation. +// TestRequestRequiredStringUnixSecondsArray invokes test_request_required_string_unix-seconds_array operation. // -// POST /test_request_string_duration_nullable_array -func (c *Client) TestRequestStringDurationNullableArray(ctx context.Context, request []NilDuration) (res Error, err error) { +// POST /test_request_required_string_unix-seconds_array +func (c *Client) TestRequestRequiredStringUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_array"), } // Validate request before sending. + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } // Run stopwatch. startTime := time.Now() @@ -27996,7 +28159,7 @@ func (c *Client) TestRequestStringDurationNullableArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28013,14 +28176,14 @@ func (c *Client) TestRequestStringDurationNullableArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_duration_nullable_array" + u.Path += "/test_request_required_string_unix-seconds_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDurationNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28032,7 +28195,7 @@ func (c *Client) TestRequestStringDurationNullableArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDurationNullableArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28040,15 +28203,18 @@ func (c *Client) TestRequestStringDurationNullableArray(ctx context.Context, req return result, nil } -// TestRequestStringDurationNullableArrayArray invokes test_request_string_duration_nullable_array_array operation. +// TestRequestRequiredStringUnixSecondsArrayArray invokes test_request_required_string_unix-seconds_array_array operation. // -// POST /test_request_string_duration_nullable_array_array -func (c *Client) TestRequestStringDurationNullableArrayArray(ctx context.Context, request [][]NilDuration) (res Error, err error) { +// POST /test_request_required_string_unix-seconds_array_array +func (c *Client) TestRequestRequiredStringUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -28082,7 +28248,7 @@ func (c *Client) TestRequestStringDurationNullableArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28099,14 +28265,14 @@ func (c *Client) TestRequestStringDurationNullableArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_duration_nullable_array_array" + u.Path += "/test_request_required_string_unix-seconds_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringDurationNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28118,7 +28284,7 @@ func (c *Client) TestRequestStringDurationNullableArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringDurationNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28126,37 +28292,14 @@ func (c *Client) TestRequestStringDurationNullableArrayArray(ctx context.Context return result, nil } -// TestRequestStringEmail invokes test_request_string_email operation. +// TestRequestRequiredStringUnixSecondsNullable invokes test_request_required_string_unix-seconds_nullable operation. // -// POST /test_request_string_email -func (c *Client) TestRequestStringEmail(ctx context.Context, request OptString) (res Error, err error) { +// POST /test_request_required_string_unix-seconds_nullable +func (c *Client) TestRequestRequiredStringUnixSecondsNullable(ctx context.Context, request NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -28169,7 +28312,7 @@ func (c *Client) TestRequestStringEmail(ctx context.Context, request OptString) c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmail", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28186,14 +28329,14 @@ func (c *Client) TestRequestStringEmail(ctx context.Context, request OptString) stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_email" + u.Path += "/test_request_required_string_unix-seconds_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringEmailRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28205,7 +28348,7 @@ func (c *Client) TestRequestStringEmail(ctx context.Context, request OptString) defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringEmailResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28213,39 +28356,17 @@ func (c *Client) TestRequestStringEmail(ctx context.Context, request OptString) return result, nil } -// TestRequestStringEmailArray invokes test_request_string_email_array operation. +// TestRequestRequiredStringUnixSecondsNullableArray invokes test_request_required_string_unix-seconds_nullable_array operation. // -// POST /test_request_string_email_array -func (c *Client) TestRequestStringEmailArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_required_string_unix-seconds_nullable_array +func (c *Client) TestRequestRequiredStringUnixSecondsNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array"), } // Validate request before sending. if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} + if request == nil { + return errors.New("nil is invalid value") } return nil }(); err != nil { @@ -28263,7 +28384,7 @@ func (c *Client) TestRequestStringEmailArray(ctx context.Context, request []stri c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28280,14 +28401,14 @@ func (c *Client) TestRequestStringEmailArray(ctx context.Context, request []stri stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_email_array" + u.Path += "/test_request_required_string_unix-seconds_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringEmailArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28299,7 +28420,7 @@ func (c *Client) TestRequestStringEmailArray(ctx context.Context, request []stri defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringEmailArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28307,46 +28428,24 @@ func (c *Client) TestRequestStringEmailArray(ctx context.Context, request []stri return result, nil } -// TestRequestStringEmailArrayArray invokes test_request_string_email_array_array operation. +// TestRequestRequiredStringUnixSecondsNullableArrayArray invokes test_request_required_string_unix-seconds_nullable_array_array operation. // -// POST /test_request_string_email_array_array -func (c *Client) TestRequestStringEmailArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_required_string_unix-seconds_nullable_array_array +func (c *Client) TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_array_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array_array"), } // Validate request before sending. if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -28374,7 +28473,7 @@ func (c *Client) TestRequestStringEmailArrayArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28391,14 +28490,14 @@ func (c *Client) TestRequestStringEmailArrayArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_email_array_array" + u.Path += "/test_request_required_string_unix-seconds_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringEmailArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28410,7 +28509,7 @@ func (c *Client) TestRequestStringEmailArrayArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringEmailArrayArrayResponse(resp, span) + result, err := decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28418,37 +28517,14 @@ func (c *Client) TestRequestStringEmailArrayArray(ctx context.Context, request [ return result, nil } -// TestRequestStringEmailNullable invokes test_request_string_email_nullable operation. +// TestRequestString invokes test_request_string operation. // -// POST /test_request_string_email_nullable -func (c *Client) TestRequestStringEmailNullable(ctx context.Context, request OptNilString) (res Error, err error) { +// POST /test_request_string +func (c *Client) TestRequestString(ctx context.Context, request OptString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable"), + otelogen.OperationID("test_request_string"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -28461,7 +28537,7 @@ func (c *Client) TestRequestStringEmailNullable(ctx context.Context, request Opt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestString", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28478,14 +28554,14 @@ func (c *Client) TestRequestStringEmailNullable(ctx context.Context, request Opt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_email_nullable" + u.Path += "/test_request_string" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringEmailNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28497,7 +28573,7 @@ func (c *Client) TestRequestStringEmailNullable(ctx context.Context, request Opt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringEmailNullableResponse(resp, span) + result, err := decodeTestRequestStringResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28505,44 +28581,14 @@ func (c *Client) TestRequestStringEmailNullable(ctx context.Context, request Opt return result, nil } -// TestRequestStringEmailNullableArray invokes test_request_string_email_nullable_array operation. +// TestRequestStringArray invokes test_request_string_array operation. // -// POST /test_request_string_email_nullable_array -func (c *Client) TestRequestStringEmailNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_string_array +func (c *Client) TestRequestStringArray(ctx context.Context, request []string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable_array"), + otelogen.OperationID("test_request_string_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -28555,7 +28601,7 @@ func (c *Client) TestRequestStringEmailNullableArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28572,14 +28618,14 @@ func (c *Client) TestRequestStringEmailNullableArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_email_nullable_array" + u.Path += "/test_request_string_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringEmailNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28591,7 +28637,7 @@ func (c *Client) TestRequestStringEmailNullableArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringEmailNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28599,12 +28645,12 @@ func (c *Client) TestRequestStringEmailNullableArray(ctx context.Context, reques return result, nil } -// TestRequestStringEmailNullableArrayArray invokes test_request_string_email_nullable_array_array operation. +// TestRequestStringArrayArray invokes test_request_string_array_array operation. // -// POST /test_request_string_email_nullable_array_array -func (c *Client) TestRequestStringEmailNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_string_array_array +func (c *Client) TestRequestStringArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable_array_array"), + otelogen.OperationID("test_request_string_array_array"), } // Validate request before sending. if err := func() error { @@ -28614,31 +28660,6 @@ func (c *Client) TestRequestStringEmailNullableArrayArray(ctx context.Context, r if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -28666,7 +28687,7 @@ func (c *Client) TestRequestStringEmailNullableArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28683,14 +28704,14 @@ func (c *Client) TestRequestStringEmailNullableArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_email_nullable_array_array" + u.Path += "/test_request_string_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringEmailNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28702,7 +28723,7 @@ func (c *Client) TestRequestStringEmailNullableArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringEmailNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28710,37 +28731,78 @@ func (c *Client) TestRequestStringEmailNullableArrayArray(ctx context.Context, r return result, nil } -// TestRequestStringHostname invokes test_request_string_hostname operation. +// TestRequestStringBinary invokes test_request_string_binary operation. // -// POST /test_request_string_hostname -func (c *Client) TestRequestStringHostname(ctx context.Context, request OptString) (res Error, err error) { +// POST /test_request_string_binary +func (c *Client) TestRequestStringBinary(ctx context.Context, request OptString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname"), + otelogen.OperationID("test_request_string_binary"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinary", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_binary" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringBinaryRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringBinaryResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringBinaryArray invokes test_request_string_binary_array operation. +// +// POST /test_request_string_binary_array +func (c *Client) TestRequestStringBinaryArray(ctx context.Context, request []string) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_binary_array"), } + // Validate request before sending. // Run stopwatch. startTime := time.Now() @@ -28753,7 +28815,7 @@ func (c *Client) TestRequestStringHostname(ctx context.Context, request OptStrin c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostname", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28770,14 +28832,14 @@ func (c *Client) TestRequestStringHostname(ctx context.Context, request OptStrin stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_hostname" + u.Path += "/test_request_string_binary_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringHostnameRequest(request, r); err != nil { + if err := encodeTestRequestStringBinaryArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28789,7 +28851,7 @@ func (c *Client) TestRequestStringHostname(ctx context.Context, request OptStrin defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringHostnameResponse(resp, span) + result, err := decodeTestRequestStringBinaryArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28797,28 +28859,20 @@ func (c *Client) TestRequestStringHostname(ctx context.Context, request OptStrin return result, nil } -// TestRequestStringHostnameArray invokes test_request_string_hostname_array operation. +// TestRequestStringBinaryArrayArray invokes test_request_string_binary_array_array operation. // -// POST /test_request_string_hostname_array -func (c *Client) TestRequestStringHostnameArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_string_binary_array_array +func (c *Client) TestRequestStringBinaryArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_array"), + otelogen.OperationID("test_request_string_binary_array_array"), } // Validate request before sending. if err := func() error { var failures []validate.FieldError for i, elem := range request { if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") + if elem == nil { + return errors.New("nil is invalid value") } return nil }(); err != nil { @@ -28847,7 +28901,7 @@ func (c *Client) TestRequestStringHostnameArray(ctx context.Context, request []s c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28864,14 +28918,14 @@ func (c *Client) TestRequestStringHostnameArray(ctx context.Context, request []s stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_hostname_array" + u.Path += "/test_request_string_binary_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringHostnameArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringBinaryArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28883,7 +28937,7 @@ func (c *Client) TestRequestStringHostnameArray(ctx context.Context, request []s defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringHostnameArrayResponse(resp, span) + result, err := decodeTestRequestStringBinaryArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -28891,45 +28945,4098 @@ func (c *Client) TestRequestStringHostnameArray(ctx context.Context, request []s return result, nil } -// TestRequestStringHostnameArrayArray invokes test_request_string_hostname_array_array operation. +// TestRequestStringBinaryNullable invokes test_request_string_binary_nullable operation. // -// POST /test_request_string_hostname_array_array -func (c *Client) TestRequestStringHostnameArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_string_binary_nullable +func (c *Client) TestRequestStringBinaryNullable(ctx context.Context, request OptNilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_array_array"), + otelogen.OperationID("test_request_string_binary_nullable"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_binary_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringBinaryNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringBinaryNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringBinaryNullableArray invokes test_request_string_binary_nullable_array operation. +// +// POST /test_request_string_binary_nullable_array +func (c *Client) TestRequestStringBinaryNullableArray(ctx context.Context, request []NilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_binary_nullable_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_binary_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringBinaryNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringBinaryNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringBinaryNullableArrayArray invokes test_request_string_binary_nullable_array_array operation. +// +// POST /test_request_string_binary_nullable_array_array +func (c *Client) TestRequestStringBinaryNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_binary_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringBinaryNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_binary_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringBinaryNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringBinaryNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringByte invokes test_request_string_byte operation. +// +// POST /test_request_string_byte +func (c *Client) TestRequestStringByte(ctx context.Context, request []byte) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_byte"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByte", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_byte" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringByteRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringByteResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringByteArray invokes test_request_string_byte_array operation. +// +// POST /test_request_string_byte_array +func (c *Client) TestRequestStringByteArray(ctx context.Context, request [][]byte) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_byte_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_byte_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringByteArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringByteArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringByteArrayArray invokes test_request_string_byte_array_array operation. +// +// POST /test_request_string_byte_array_array +func (c *Client) TestRequestStringByteArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_byte_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_byte_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringByteArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringByteArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringByteNullable invokes test_request_string_byte_nullable operation. +// +// POST /test_request_string_byte_nullable +func (c *Client) TestRequestStringByteNullable(ctx context.Context, request OptNilByte) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_byte_nullable"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_byte_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringByteNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringByteNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringByteNullableArray invokes test_request_string_byte_nullable_array operation. +// +// POST /test_request_string_byte_nullable_array +func (c *Client) TestRequestStringByteNullableArray(ctx context.Context, request [][]byte) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_byte_nullable_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_byte_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringByteNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringByteNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringByteNullableArrayArray invokes test_request_string_byte_nullable_array_array operation. +// +// POST /test_request_string_byte_nullable_array_array +func (c *Client) TestRequestStringByteNullableArrayArray(ctx context.Context, request [][][]byte) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_byte_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringByteNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_byte_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringByteNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringByteNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDate invokes test_request_string_date operation. +// +// POST /test_request_string_date +func (c *Client) TestRequestStringDate(ctx context.Context, request OptDate) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDate", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateArray invokes test_request_string_date_array operation. +// +// POST /test_request_string_date_array +func (c *Client) TestRequestStringDateArray(ctx context.Context, request []time.Time) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateArrayArray invokes test_request_string_date_array_array operation. +// +// POST /test_request_string_date_array_array +func (c *Client) TestRequestStringDateArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateNullable invokes test_request_string_date_nullable operation. +// +// POST /test_request_string_date_nullable +func (c *Client) TestRequestStringDateNullable(ctx context.Context, request OptNilDate) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date_nullable"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateNullableArray invokes test_request_string_date_nullable_array operation. +// +// POST /test_request_string_date_nullable_array +func (c *Client) TestRequestStringDateNullableArray(ctx context.Context, request []NilDate) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date_nullable_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateNullableArrayArray invokes test_request_string_date_nullable_array_array operation. +// +// POST /test_request_string_date_nullable_array_array +func (c *Client) TestRequestStringDateNullableArrayArray(ctx context.Context, request [][]NilDate) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateTime invokes test_request_string_date-time operation. +// +// POST /test_request_string_date-time +func (c *Client) TestRequestStringDateTime(ctx context.Context, request OptDateTime) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date-time"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTime", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date-time" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateTimeRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateTimeResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateTimeArray invokes test_request_string_date-time_array operation. +// +// POST /test_request_string_date-time_array +func (c *Client) TestRequestStringDateTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date-time_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date-time_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateTimeArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateTimeArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateTimeArrayArray invokes test_request_string_date-time_array_array operation. +// +// POST /test_request_string_date-time_array_array +func (c *Client) TestRequestStringDateTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date-time_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date-time_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateTimeArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateTimeArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateTimeNullable invokes test_request_string_date-time_nullable operation. +// +// POST /test_request_string_date-time_nullable +func (c *Client) TestRequestStringDateTimeNullable(ctx context.Context, request OptNilDateTime) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date-time_nullable"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date-time_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateTimeNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateTimeNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateTimeNullableArray invokes test_request_string_date-time_nullable_array operation. +// +// POST /test_request_string_date-time_nullable_array +func (c *Client) TestRequestStringDateTimeNullableArray(ctx context.Context, request []NilDateTime) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date-time_nullable_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date-time_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateTimeNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateTimeNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDateTimeNullableArrayArray invokes test_request_string_date-time_nullable_array_array operation. +// +// POST /test_request_string_date-time_nullable_array_array +func (c *Client) TestRequestStringDateTimeNullableArrayArray(ctx context.Context, request [][]NilDateTime) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_date-time_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDateTimeNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_date-time_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDateTimeNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDateTimeNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDuration invokes test_request_string_duration operation. +// +// POST /test_request_string_duration +func (c *Client) TestRequestStringDuration(ctx context.Context, request OptDuration) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_duration"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDuration", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_duration" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDurationRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDurationResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDurationArray invokes test_request_string_duration_array operation. +// +// POST /test_request_string_duration_array +func (c *Client) TestRequestStringDurationArray(ctx context.Context, request []time.Duration) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_duration_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_duration_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDurationArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDurationArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDurationArrayArray invokes test_request_string_duration_array_array operation. +// +// POST /test_request_string_duration_array_array +func (c *Client) TestRequestStringDurationArrayArray(ctx context.Context, request [][]time.Duration) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_duration_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_duration_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDurationArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDurationArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDurationNullable invokes test_request_string_duration_nullable operation. +// +// POST /test_request_string_duration_nullable +func (c *Client) TestRequestStringDurationNullable(ctx context.Context, request OptNilDuration) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_duration_nullable"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_duration_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDurationNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDurationNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDurationNullableArray invokes test_request_string_duration_nullable_array operation. +// +// POST /test_request_string_duration_nullable_array +func (c *Client) TestRequestStringDurationNullableArray(ctx context.Context, request []NilDuration) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_duration_nullable_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_duration_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDurationNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDurationNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringDurationNullableArrayArray invokes test_request_string_duration_nullable_array_array operation. +// +// POST /test_request_string_duration_nullable_array_array +func (c *Client) TestRequestStringDurationNullableArrayArray(ctx context.Context, request [][]NilDuration) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_duration_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringDurationNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_duration_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringDurationNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringDurationNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringEmail invokes test_request_string_email operation. +// +// POST /test_request_string_email +func (c *Client) TestRequestStringEmail(ctx context.Context, request OptString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_email"), + } + // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmail", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_email" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringEmailRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringEmailResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringEmailArray invokes test_request_string_email_array operation. +// +// POST /test_request_string_email_array +func (c *Client) TestRequestStringEmailArray(ctx context.Context, request []string) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_email_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_email_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringEmailArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringEmailArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringEmailArrayArray invokes test_request_string_email_array_array operation. +// +// POST /test_request_string_email_array_array +func (c *Client) TestRequestStringEmailArrayArray(ctx context.Context, request [][]string) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_email_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_email_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringEmailArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringEmailArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringEmailNullable invokes test_request_string_email_nullable operation. +// +// POST /test_request_string_email_nullable +func (c *Client) TestRequestStringEmailNullable(ctx context.Context, request OptNilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_email_nullable"), + } + // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_email_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringEmailNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringEmailNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringEmailNullableArray invokes test_request_string_email_nullable_array operation. +// +// POST /test_request_string_email_nullable_array +func (c *Client) TestRequestStringEmailNullableArray(ctx context.Context, request []NilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_email_nullable_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_email_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringEmailNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringEmailNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringEmailNullableArrayArray invokes test_request_string_email_nullable_array_array operation. +// +// POST /test_request_string_email_nullable_array_array +func (c *Client) TestRequestStringEmailNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_email_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringEmailNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_email_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringEmailNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringEmailNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringHostname invokes test_request_string_hostname operation. +// +// POST /test_request_string_hostname +func (c *Client) TestRequestStringHostname(ctx context.Context, request OptString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_hostname"), + } + // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostname", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_hostname" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringHostnameRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringHostnameResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringHostnameArray invokes test_request_string_hostname_array operation. +// +// POST /test_request_string_hostname_array +func (c *Client) TestRequestStringHostnameArray(ctx context.Context, request []string) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_hostname_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_hostname_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringHostnameArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringHostnameArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringHostnameArrayArray invokes test_request_string_hostname_array_array operation. +// +// POST /test_request_string_hostname_array_array +func (c *Client) TestRequestStringHostnameArrayArray(ctx context.Context, request [][]string) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_hostname_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_hostname_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringHostnameArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringHostnameArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringHostnameNullable invokes test_request_string_hostname_nullable operation. +// +// POST /test_request_string_hostname_nullable +func (c *Client) TestRequestStringHostnameNullable(ctx context.Context, request OptNilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_hostname_nullable"), + } + // Validate request before sending. + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_hostname_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringHostnameNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringHostnameNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringHostnameNullableArray invokes test_request_string_hostname_nullable_array operation. +// +// POST /test_request_string_hostname_nullable_array +func (c *Client) TestRequestStringHostnameNullableArray(ctx context.Context, request []NilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_hostname_nullable_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_hostname_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringHostnameNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringHostnameNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringHostnameNullableArrayArray invokes test_request_string_hostname_nullable_array_array operation. +// +// POST /test_request_string_hostname_nullable_array_array +func (c *Client) TestRequestStringHostnameNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_hostname_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_hostname_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringHostnameNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringHostnameNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringIP invokes test_request_string_ip operation. +// +// POST /test_request_string_ip +func (c *Client) TestRequestStringIP(ctx context.Context, request OptIP) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_ip"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIP", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_ip" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringIPRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringIPResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringIPArray invokes test_request_string_ip_array operation. +// +// POST /test_request_string_ip_array +func (c *Client) TestRequestStringIPArray(ctx context.Context, request []netip.Addr) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_ip_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_ip_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringIPArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringIPArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringIPArrayArray invokes test_request_string_ip_array_array operation. +// +// POST /test_request_string_ip_array_array +func (c *Client) TestRequestStringIPArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_ip_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_ip_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringIPArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringIPArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringIPNullable invokes test_request_string_ip_nullable operation. +// +// POST /test_request_string_ip_nullable +func (c *Client) TestRequestStringIPNullable(ctx context.Context, request OptNilIP) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_ip_nullable"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_ip_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringIPNullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringIPNullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringIPNullableArray invokes test_request_string_ip_nullable_array operation. +// +// POST /test_request_string_ip_nullable_array +func (c *Client) TestRequestStringIPNullableArray(ctx context.Context, request []NilIP) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_ip_nullable_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_ip_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringIPNullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringIPNullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringIPNullableArrayArray invokes test_request_string_ip_nullable_array_array operation. +// +// POST /test_request_string_ip_nullable_array_array +func (c *Client) TestRequestStringIPNullableArrayArray(ctx context.Context, request [][]NilIP) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_ip_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_ip_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringIPNullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringIPNullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt32 invokes test_request_string_int32 operation. +// +// POST /test_request_string_int32 +func (c *Client) TestRequestStringInt32(ctx context.Context, request OptStringInt32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int32"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int32" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt32Request(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt32Response(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt32Array invokes test_request_string_int32_array operation. +// +// POST /test_request_string_int32_array +func (c *Client) TestRequestStringInt32Array(ctx context.Context, request []int32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int32_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32Array", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int32_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt32ArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt32ArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt32ArrayArray invokes test_request_string_int32_array_array operation. +// +// POST /test_request_string_int32_array_array +func (c *Client) TestRequestStringInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int32_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32ArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int32_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt32ArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt32ArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt32Nullable invokes test_request_string_int32_nullable operation. +// +// POST /test_request_string_int32_nullable +func (c *Client) TestRequestStringInt32Nullable(ctx context.Context, request OptNilStringInt32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int32_nullable"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32Nullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int32_nullable" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt32NullableRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt32NullableResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt32NullableArray invokes test_request_string_int32_nullable_array operation. +// +// POST /test_request_string_int32_nullable_array +func (c *Client) TestRequestStringInt32NullableArray(ctx context.Context, request []NilStringInt32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int32_nullable_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32NullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int32_nullable_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt32NullableArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt32NullableArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt32NullableArrayArray invokes test_request_string_int32_nullable_array_array operation. +// +// POST /test_request_string_int32_nullable_array_array +func (c *Client) TestRequestStringInt32NullableArrayArray(ctx context.Context, request [][]NilStringInt32) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int32_nullable_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32NullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int32_nullable_array_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt32NullableArrayArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt32NullableArrayArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt64 invokes test_request_string_int64 operation. +// +// POST /test_request_string_int64 +func (c *Client) TestRequestStringInt64(ctx context.Context, request OptStringInt64) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int64"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int64" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt64Request(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt64Response(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt64Array invokes test_request_string_int64_array operation. +// +// POST /test_request_string_int64_array +func (c *Client) TestRequestStringInt64Array(ctx context.Context, request []int64) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int64_array"), + } + // Validate request before sending. + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, otelAttrs...) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64Array", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindClient), + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, otelAttrs...) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.serverURL) + u.Path += "/test_request_string_int64_array" + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u, nil) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringInt64ArrayRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeTestRequestStringInt64ArrayResponse(resp, span) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringInt64ArrayArray invokes test_request_string_int64_array_array operation. +// +// POST /test_request_string_int64_array_array +func (c *Client) TestRequestStringInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_int64_array_array"), + } + // Validate request before sending. + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") } return nil }(); err != nil { @@ -28958,7 +33065,7 @@ func (c *Client) TestRequestStringHostnameArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -28975,14 +33082,14 @@ func (c *Client) TestRequestStringHostnameArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_hostname_array_array" + u.Path += "/test_request_string_int64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringHostnameArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringInt64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -28994,7 +33101,7 @@ func (c *Client) TestRequestStringHostnameArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringHostnameArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringInt64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29002,37 +33109,14 @@ func (c *Client) TestRequestStringHostnameArrayArray(ctx context.Context, reques return result, nil } -// TestRequestStringHostnameNullable invokes test_request_string_hostname_nullable operation. +// TestRequestStringInt64Nullable invokes test_request_string_int64_nullable operation. // -// POST /test_request_string_hostname_nullable -func (c *Client) TestRequestStringHostnameNullable(ctx context.Context, request OptNilString) (res Error, err error) { +// POST /test_request_string_int64_nullable +func (c *Client) TestRequestStringInt64Nullable(ctx context.Context, request OptNilStringInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable"), + otelogen.OperationID("test_request_string_int64_nullable"), } // Validate request before sending. - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -29045,7 +33129,7 @@ func (c *Client) TestRequestStringHostnameNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29062,14 +33146,14 @@ func (c *Client) TestRequestStringHostnameNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_hostname_nullable" + u.Path += "/test_request_string_int64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringHostnameNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringInt64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29081,7 +33165,7 @@ func (c *Client) TestRequestStringHostnameNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringHostnameNullableResponse(resp, span) + result, err := decodeTestRequestStringInt64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29089,44 +33173,14 @@ func (c *Client) TestRequestStringHostnameNullable(ctx context.Context, request return result, nil } -// TestRequestStringHostnameNullableArray invokes test_request_string_hostname_nullable_array operation. +// TestRequestStringInt64NullableArray invokes test_request_string_int64_nullable_array operation. // -// POST /test_request_string_hostname_nullable_array -func (c *Client) TestRequestStringHostnameNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_string_int64_nullable_array +func (c *Client) TestRequestStringInt64NullableArray(ctx context.Context, request []NilStringInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable_array"), + otelogen.OperationID("test_request_string_int64_nullable_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -29139,7 +33193,7 @@ func (c *Client) TestRequestStringHostnameNullableArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29156,14 +33210,14 @@ func (c *Client) TestRequestStringHostnameNullableArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_hostname_nullable_array" + u.Path += "/test_request_string_int64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringHostnameNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringInt64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29175,7 +33229,7 @@ func (c *Client) TestRequestStringHostnameNullableArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringHostnameNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringInt64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29183,12 +33237,12 @@ func (c *Client) TestRequestStringHostnameNullableArray(ctx context.Context, req return result, nil } -// TestRequestStringHostnameNullableArrayArray invokes test_request_string_hostname_nullable_array_array operation. +// TestRequestStringInt64NullableArrayArray invokes test_request_string_int64_nullable_array_array operation. // -// POST /test_request_string_hostname_nullable_array_array -func (c *Client) TestRequestStringHostnameNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_string_int64_nullable_array_array +func (c *Client) TestRequestStringInt64NullableArrayArray(ctx context.Context, request [][]NilStringInt64) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable_array_array"), + otelogen.OperationID("test_request_string_int64_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -29198,31 +33252,6 @@ func (c *Client) TestRequestStringHostnameNullableArrayArray(ctx context.Context if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -29250,7 +33279,7 @@ func (c *Client) TestRequestStringHostnameNullableArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringHostnameNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29267,14 +33296,14 @@ func (c *Client) TestRequestStringHostnameNullableArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_hostname_nullable_array_array" + u.Path += "/test_request_string_int64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringHostnameNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringInt64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29286,7 +33315,7 @@ func (c *Client) TestRequestStringHostnameNullableArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringHostnameNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringInt64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29294,12 +33323,12 @@ func (c *Client) TestRequestStringHostnameNullableArrayArray(ctx context.Context return result, nil } -// TestRequestStringIP invokes test_request_string_ip operation. +// TestRequestStringIpv4 invokes test_request_string_ipv4 operation. // -// POST /test_request_string_ip -func (c *Client) TestRequestStringIP(ctx context.Context, request OptIP) (res Error, err error) { +// POST /test_request_string_ipv4 +func (c *Client) TestRequestStringIpv4(ctx context.Context, request OptIPv4) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip"), + otelogen.OperationID("test_request_string_ipv4"), } // Validate request before sending. @@ -29314,7 +33343,7 @@ func (c *Client) TestRequestStringIP(ctx context.Context, request OptIP) (res Er c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIP", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29331,14 +33360,14 @@ func (c *Client) TestRequestStringIP(ctx context.Context, request OptIP) (res Er stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ip" + u.Path += "/test_request_string_ipv4" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIPRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv4Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29350,7 +33379,7 @@ func (c *Client) TestRequestStringIP(ctx context.Context, request OptIP) (res Er defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIPResponse(resp, span) + result, err := decodeTestRequestStringIpv4Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29358,12 +33387,12 @@ func (c *Client) TestRequestStringIP(ctx context.Context, request OptIP) (res Er return result, nil } -// TestRequestStringIPArray invokes test_request_string_ip_array operation. +// TestRequestStringIpv4Array invokes test_request_string_ipv4_array operation. // -// POST /test_request_string_ip_array -func (c *Client) TestRequestStringIPArray(ctx context.Context, request []netip.Addr) (res Error, err error) { +// POST /test_request_string_ipv4_array +func (c *Client) TestRequestStringIpv4Array(ctx context.Context, request []netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_array"), + otelogen.OperationID("test_request_string_ipv4_array"), } // Validate request before sending. @@ -29378,7 +33407,7 @@ func (c *Client) TestRequestStringIPArray(ctx context.Context, request []netip.A c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29395,14 +33424,14 @@ func (c *Client) TestRequestStringIPArray(ctx context.Context, request []netip.A stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ip_array" + u.Path += "/test_request_string_ipv4_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIPArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv4ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29414,7 +33443,7 @@ func (c *Client) TestRequestStringIPArray(ctx context.Context, request []netip.A defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIPArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv4ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29422,12 +33451,12 @@ func (c *Client) TestRequestStringIPArray(ctx context.Context, request []netip.A return result, nil } -// TestRequestStringIPArrayArray invokes test_request_string_ip_array_array operation. +// TestRequestStringIpv4ArrayArray invokes test_request_string_ipv4_array_array operation. // -// POST /test_request_string_ip_array_array -func (c *Client) TestRequestStringIPArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { +// POST /test_request_string_ipv4_array_array +func (c *Client) TestRequestStringIpv4ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_array_array"), + otelogen.OperationID("test_request_string_ipv4_array_array"), } // Validate request before sending. if err := func() error { @@ -29464,7 +33493,7 @@ func (c *Client) TestRequestStringIPArrayArray(ctx context.Context, request [][] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29481,14 +33510,14 @@ func (c *Client) TestRequestStringIPArrayArray(ctx context.Context, request [][] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ip_array_array" + u.Path += "/test_request_string_ipv4_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIPArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv4ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29500,7 +33529,7 @@ func (c *Client) TestRequestStringIPArrayArray(ctx context.Context, request [][] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIPArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv4ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29508,12 +33537,12 @@ func (c *Client) TestRequestStringIPArrayArray(ctx context.Context, request [][] return result, nil } -// TestRequestStringIPNullable invokes test_request_string_ip_nullable operation. +// TestRequestStringIpv4Nullable invokes test_request_string_ipv4_nullable operation. // -// POST /test_request_string_ip_nullable -func (c *Client) TestRequestStringIPNullable(ctx context.Context, request OptNilIP) (res Error, err error) { +// POST /test_request_string_ipv4_nullable +func (c *Client) TestRequestStringIpv4Nullable(ctx context.Context, request OptNilIPv4) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable"), + otelogen.OperationID("test_request_string_ipv4_nullable"), } // Validate request before sending. @@ -29528,7 +33557,7 @@ func (c *Client) TestRequestStringIPNullable(ctx context.Context, request OptNil c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29545,14 +33574,14 @@ func (c *Client) TestRequestStringIPNullable(ctx context.Context, request OptNil stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ip_nullable" + u.Path += "/test_request_string_ipv4_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIPNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv4NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29564,7 +33593,7 @@ func (c *Client) TestRequestStringIPNullable(ctx context.Context, request OptNil defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIPNullableResponse(resp, span) + result, err := decodeTestRequestStringIpv4NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29572,12 +33601,12 @@ func (c *Client) TestRequestStringIPNullable(ctx context.Context, request OptNil return result, nil } -// TestRequestStringIPNullableArray invokes test_request_string_ip_nullable_array operation. +// TestRequestStringIpv4NullableArray invokes test_request_string_ipv4_nullable_array operation. // -// POST /test_request_string_ip_nullable_array -func (c *Client) TestRequestStringIPNullableArray(ctx context.Context, request []NilIP) (res Error, err error) { +// POST /test_request_string_ipv4_nullable_array +func (c *Client) TestRequestStringIpv4NullableArray(ctx context.Context, request []NilIPv4) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable_array"), + otelogen.OperationID("test_request_string_ipv4_nullable_array"), } // Validate request before sending. @@ -29592,7 +33621,7 @@ func (c *Client) TestRequestStringIPNullableArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29609,14 +33638,14 @@ func (c *Client) TestRequestStringIPNullableArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ip_nullable_array" + u.Path += "/test_request_string_ipv4_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIPNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv4NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29628,7 +33657,7 @@ func (c *Client) TestRequestStringIPNullableArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIPNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv4NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29636,12 +33665,12 @@ func (c *Client) TestRequestStringIPNullableArray(ctx context.Context, request [ return result, nil } -// TestRequestStringIPNullableArrayArray invokes test_request_string_ip_nullable_array_array operation. +// TestRequestStringIpv4NullableArrayArray invokes test_request_string_ipv4_nullable_array_array operation. // -// POST /test_request_string_ip_nullable_array_array -func (c *Client) TestRequestStringIPNullableArrayArray(ctx context.Context, request [][]NilIP) (res Error, err error) { +// POST /test_request_string_ipv4_nullable_array_array +func (c *Client) TestRequestStringIpv4NullableArrayArray(ctx context.Context, request [][]NilIPv4) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable_array_array"), + otelogen.OperationID("test_request_string_ipv4_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -29678,7 +33707,7 @@ func (c *Client) TestRequestStringIPNullableArrayArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIPNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29695,14 +33724,14 @@ func (c *Client) TestRequestStringIPNullableArrayArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ip_nullable_array_array" + u.Path += "/test_request_string_ipv4_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIPNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv4NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29714,7 +33743,7 @@ func (c *Client) TestRequestStringIPNullableArrayArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIPNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv4NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29722,12 +33751,12 @@ func (c *Client) TestRequestStringIPNullableArrayArray(ctx context.Context, requ return result, nil } -// TestRequestStringInt32 invokes test_request_string_int32 operation. +// TestRequestStringIpv6 invokes test_request_string_ipv6 operation. // -// POST /test_request_string_int32 -func (c *Client) TestRequestStringInt32(ctx context.Context, request OptStringInt32) (res Error, err error) { +// POST /test_request_string_ipv6 +func (c *Client) TestRequestStringIpv6(ctx context.Context, request OptIPv6) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32"), + otelogen.OperationID("test_request_string_ipv6"), } // Validate request before sending. @@ -29742,7 +33771,7 @@ func (c *Client) TestRequestStringInt32(ctx context.Context, request OptStringIn c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29759,14 +33788,14 @@ func (c *Client) TestRequestStringInt32(ctx context.Context, request OptStringIn stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int32" + u.Path += "/test_request_string_ipv6" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt32Request(request, r); err != nil { + if err := encodeTestRequestStringIpv6Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29778,7 +33807,7 @@ func (c *Client) TestRequestStringInt32(ctx context.Context, request OptStringIn defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt32Response(resp, span) + result, err := decodeTestRequestStringIpv6Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29786,12 +33815,12 @@ func (c *Client) TestRequestStringInt32(ctx context.Context, request OptStringIn return result, nil } -// TestRequestStringInt32Array invokes test_request_string_int32_array operation. +// TestRequestStringIpv6Array invokes test_request_string_ipv6_array operation. // -// POST /test_request_string_int32_array -func (c *Client) TestRequestStringInt32Array(ctx context.Context, request []int32) (res Error, err error) { +// POST /test_request_string_ipv6_array +func (c *Client) TestRequestStringIpv6Array(ctx context.Context, request []netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_array"), + otelogen.OperationID("test_request_string_ipv6_array"), } // Validate request before sending. @@ -29806,7 +33835,7 @@ func (c *Client) TestRequestStringInt32Array(ctx context.Context, request []int3 c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29823,14 +33852,14 @@ func (c *Client) TestRequestStringInt32Array(ctx context.Context, request []int3 stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int32_array" + u.Path += "/test_request_string_ipv6_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt32ArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv6ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29842,7 +33871,7 @@ func (c *Client) TestRequestStringInt32Array(ctx context.Context, request []int3 defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt32ArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv6ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29850,12 +33879,12 @@ func (c *Client) TestRequestStringInt32Array(ctx context.Context, request []int3 return result, nil } -// TestRequestStringInt32ArrayArray invokes test_request_string_int32_array_array operation. +// TestRequestStringIpv6ArrayArray invokes test_request_string_ipv6_array_array operation. // -// POST /test_request_string_int32_array_array -func (c *Client) TestRequestStringInt32ArrayArray(ctx context.Context, request [][]int32) (res Error, err error) { +// POST /test_request_string_ipv6_array_array +func (c *Client) TestRequestStringIpv6ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_array_array"), + otelogen.OperationID("test_request_string_ipv6_array_array"), } // Validate request before sending. if err := func() error { @@ -29892,7 +33921,7 @@ func (c *Client) TestRequestStringInt32ArrayArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29909,14 +33938,14 @@ func (c *Client) TestRequestStringInt32ArrayArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int32_array_array" + u.Path += "/test_request_string_ipv6_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt32ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv6ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29928,7 +33957,7 @@ func (c *Client) TestRequestStringInt32ArrayArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt32ArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv6ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -29936,12 +33965,12 @@ func (c *Client) TestRequestStringInt32ArrayArray(ctx context.Context, request [ return result, nil } -// TestRequestStringInt32Nullable invokes test_request_string_int32_nullable operation. +// TestRequestStringIpv6Nullable invokes test_request_string_ipv6_nullable operation. // -// POST /test_request_string_int32_nullable -func (c *Client) TestRequestStringInt32Nullable(ctx context.Context, request OptNilStringInt32) (res Error, err error) { +// POST /test_request_string_ipv6_nullable +func (c *Client) TestRequestStringIpv6Nullable(ctx context.Context, request OptNilIPv6) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable"), + otelogen.OperationID("test_request_string_ipv6_nullable"), } // Validate request before sending. @@ -29956,7 +33985,7 @@ func (c *Client) TestRequestStringInt32Nullable(ctx context.Context, request Opt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -29973,14 +34002,14 @@ func (c *Client) TestRequestStringInt32Nullable(ctx context.Context, request Opt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int32_nullable" + u.Path += "/test_request_string_ipv6_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt32NullableRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv6NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -29992,7 +34021,7 @@ func (c *Client) TestRequestStringInt32Nullable(ctx context.Context, request Opt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt32NullableResponse(resp, span) + result, err := decodeTestRequestStringIpv6NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30000,12 +34029,12 @@ func (c *Client) TestRequestStringInt32Nullable(ctx context.Context, request Opt return result, nil } -// TestRequestStringInt32NullableArray invokes test_request_string_int32_nullable_array operation. +// TestRequestStringIpv6NullableArray invokes test_request_string_ipv6_nullable_array operation. // -// POST /test_request_string_int32_nullable_array -func (c *Client) TestRequestStringInt32NullableArray(ctx context.Context, request []NilStringInt32) (res Error, err error) { +// POST /test_request_string_ipv6_nullable_array +func (c *Client) TestRequestStringIpv6NullableArray(ctx context.Context, request []NilIPv6) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable_array"), + otelogen.OperationID("test_request_string_ipv6_nullable_array"), } // Validate request before sending. @@ -30020,7 +34049,7 @@ func (c *Client) TestRequestStringInt32NullableArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30037,14 +34066,14 @@ func (c *Client) TestRequestStringInt32NullableArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int32_nullable_array" + u.Path += "/test_request_string_ipv6_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt32NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv6NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30056,7 +34085,7 @@ func (c *Client) TestRequestStringInt32NullableArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt32NullableArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv6NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30064,12 +34093,12 @@ func (c *Client) TestRequestStringInt32NullableArray(ctx context.Context, reques return result, nil } -// TestRequestStringInt32NullableArrayArray invokes test_request_string_int32_nullable_array_array operation. +// TestRequestStringIpv6NullableArrayArray invokes test_request_string_ipv6_nullable_array_array operation. // -// POST /test_request_string_int32_nullable_array_array -func (c *Client) TestRequestStringInt32NullableArrayArray(ctx context.Context, request [][]NilStringInt32) (res Error, err error) { +// POST /test_request_string_ipv6_nullable_array_array +func (c *Client) TestRequestStringIpv6NullableArrayArray(ctx context.Context, request [][]NilIPv6) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable_array_array"), + otelogen.OperationID("test_request_string_ipv6_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -30106,7 +34135,7 @@ func (c *Client) TestRequestStringInt32NullableArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt32NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30123,14 +34152,14 @@ func (c *Client) TestRequestStringInt32NullableArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int32_nullable_array_array" + u.Path += "/test_request_string_ipv6_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt32NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringIpv6NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30142,7 +34171,7 @@ func (c *Client) TestRequestStringInt32NullableArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt32NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringIpv6NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30150,12 +34179,12 @@ func (c *Client) TestRequestStringInt32NullableArrayArray(ctx context.Context, r return result, nil } -// TestRequestStringInt64 invokes test_request_string_int64 operation. +// TestRequestStringNullable invokes test_request_string_nullable operation. // -// POST /test_request_string_int64 -func (c *Client) TestRequestStringInt64(ctx context.Context, request OptStringInt64) (res Error, err error) { +// POST /test_request_string_nullable +func (c *Client) TestRequestStringNullable(ctx context.Context, request OptNilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64"), + otelogen.OperationID("test_request_string_nullable"), } // Validate request before sending. @@ -30170,7 +34199,7 @@ func (c *Client) TestRequestStringInt64(ctx context.Context, request OptStringIn c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30187,14 +34216,14 @@ func (c *Client) TestRequestStringInt64(ctx context.Context, request OptStringIn stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int64" + u.Path += "/test_request_string_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt64Request(request, r); err != nil { + if err := encodeTestRequestStringNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30206,7 +34235,7 @@ func (c *Client) TestRequestStringInt64(ctx context.Context, request OptStringIn defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt64Response(resp, span) + result, err := decodeTestRequestStringNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30214,12 +34243,12 @@ func (c *Client) TestRequestStringInt64(ctx context.Context, request OptStringIn return result, nil } -// TestRequestStringInt64Array invokes test_request_string_int64_array operation. +// TestRequestStringNullableArray invokes test_request_string_nullable_array operation. // -// POST /test_request_string_int64_array -func (c *Client) TestRequestStringInt64Array(ctx context.Context, request []int64) (res Error, err error) { +// POST /test_request_string_nullable_array +func (c *Client) TestRequestStringNullableArray(ctx context.Context, request []NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_array"), + otelogen.OperationID("test_request_string_nullable_array"), } // Validate request before sending. @@ -30234,7 +34263,7 @@ func (c *Client) TestRequestStringInt64Array(ctx context.Context, request []int6 c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30251,14 +34280,14 @@ func (c *Client) TestRequestStringInt64Array(ctx context.Context, request []int6 stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int64_array" + u.Path += "/test_request_string_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt64ArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30270,7 +34299,7 @@ func (c *Client) TestRequestStringInt64Array(ctx context.Context, request []int6 defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt64ArrayResponse(resp, span) + result, err := decodeTestRequestStringNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30278,12 +34307,12 @@ func (c *Client) TestRequestStringInt64Array(ctx context.Context, request []int6 return result, nil } -// TestRequestStringInt64ArrayArray invokes test_request_string_int64_array_array operation. +// TestRequestStringNullableArrayArray invokes test_request_string_nullable_array_array operation. // -// POST /test_request_string_int64_array_array -func (c *Client) TestRequestStringInt64ArrayArray(ctx context.Context, request [][]int64) (res Error, err error) { +// POST /test_request_string_nullable_array_array +func (c *Client) TestRequestStringNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_array_array"), + otelogen.OperationID("test_request_string_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -30320,7 +34349,7 @@ func (c *Client) TestRequestStringInt64ArrayArray(ctx context.Context, request [ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30337,14 +34366,14 @@ func (c *Client) TestRequestStringInt64ArrayArray(ctx context.Context, request [ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int64_array_array" + u.Path += "/test_request_string_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt64ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30356,7 +34385,7 @@ func (c *Client) TestRequestStringInt64ArrayArray(ctx context.Context, request [ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt64ArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30364,12 +34393,12 @@ func (c *Client) TestRequestStringInt64ArrayArray(ctx context.Context, request [ return result, nil } -// TestRequestStringInt64Nullable invokes test_request_string_int64_nullable operation. +// TestRequestStringPassword invokes test_request_string_password operation. // -// POST /test_request_string_int64_nullable -func (c *Client) TestRequestStringInt64Nullable(ctx context.Context, request OptNilStringInt64) (res Error, err error) { +// POST /test_request_string_password +func (c *Client) TestRequestStringPassword(ctx context.Context, request OptString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable"), + otelogen.OperationID("test_request_string_password"), } // Validate request before sending. @@ -30384,7 +34413,7 @@ func (c *Client) TestRequestStringInt64Nullable(ctx context.Context, request Opt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPassword", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30401,14 +34430,14 @@ func (c *Client) TestRequestStringInt64Nullable(ctx context.Context, request Opt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int64_nullable" + u.Path += "/test_request_string_password" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt64NullableRequest(request, r); err != nil { + if err := encodeTestRequestStringPasswordRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30420,7 +34449,7 @@ func (c *Client) TestRequestStringInt64Nullable(ctx context.Context, request Opt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt64NullableResponse(resp, span) + result, err := decodeTestRequestStringPasswordResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30428,12 +34457,12 @@ func (c *Client) TestRequestStringInt64Nullable(ctx context.Context, request Opt return result, nil } -// TestRequestStringInt64NullableArray invokes test_request_string_int64_nullable_array operation. +// TestRequestStringPasswordArray invokes test_request_string_password_array operation. // -// POST /test_request_string_int64_nullable_array -func (c *Client) TestRequestStringInt64NullableArray(ctx context.Context, request []NilStringInt64) (res Error, err error) { +// POST /test_request_string_password_array +func (c *Client) TestRequestStringPasswordArray(ctx context.Context, request []string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable_array"), + otelogen.OperationID("test_request_string_password_array"), } // Validate request before sending. @@ -30448,7 +34477,7 @@ func (c *Client) TestRequestStringInt64NullableArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30465,14 +34494,14 @@ func (c *Client) TestRequestStringInt64NullableArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int64_nullable_array" + u.Path += "/test_request_string_password_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt64NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringPasswordArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30484,7 +34513,7 @@ func (c *Client) TestRequestStringInt64NullableArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt64NullableArrayResponse(resp, span) + result, err := decodeTestRequestStringPasswordArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30492,12 +34521,12 @@ func (c *Client) TestRequestStringInt64NullableArray(ctx context.Context, reques return result, nil } -// TestRequestStringInt64NullableArrayArray invokes test_request_string_int64_nullable_array_array operation. +// TestRequestStringPasswordArrayArray invokes test_request_string_password_array_array operation. // -// POST /test_request_string_int64_nullable_array_array -func (c *Client) TestRequestStringInt64NullableArrayArray(ctx context.Context, request [][]NilStringInt64) (res Error, err error) { +// POST /test_request_string_password_array_array +func (c *Client) TestRequestStringPasswordArrayArray(ctx context.Context, request [][]string) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable_array_array"), + otelogen.OperationID("test_request_string_password_array_array"), } // Validate request before sending. if err := func() error { @@ -30534,7 +34563,7 @@ func (c *Client) TestRequestStringInt64NullableArrayArray(ctx context.Context, r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringInt64NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30551,14 +34580,14 @@ func (c *Client) TestRequestStringInt64NullableArrayArray(ctx context.Context, r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_int64_nullable_array_array" + u.Path += "/test_request_string_password_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringInt64NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringPasswordArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30570,7 +34599,7 @@ func (c *Client) TestRequestStringInt64NullableArrayArray(ctx context.Context, r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringInt64NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringPasswordArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30578,12 +34607,12 @@ func (c *Client) TestRequestStringInt64NullableArrayArray(ctx context.Context, r return result, nil } -// TestRequestStringIpv4 invokes test_request_string_ipv4 operation. +// TestRequestStringPasswordNullable invokes test_request_string_password_nullable operation. // -// POST /test_request_string_ipv4 -func (c *Client) TestRequestStringIpv4(ctx context.Context, request OptIPv4) (res Error, err error) { +// POST /test_request_string_password_nullable +func (c *Client) TestRequestStringPasswordNullable(ctx context.Context, request OptNilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4"), + otelogen.OperationID("test_request_string_password_nullable"), } // Validate request before sending. @@ -30598,7 +34627,7 @@ func (c *Client) TestRequestStringIpv4(ctx context.Context, request OptIPv4) (re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30615,14 +34644,14 @@ func (c *Client) TestRequestStringIpv4(ctx context.Context, request OptIPv4) (re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv4" + u.Path += "/test_request_string_password_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv4Request(request, r); err != nil { + if err := encodeTestRequestStringPasswordNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30634,7 +34663,7 @@ func (c *Client) TestRequestStringIpv4(ctx context.Context, request OptIPv4) (re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv4Response(resp, span) + result, err := decodeTestRequestStringPasswordNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30642,12 +34671,12 @@ func (c *Client) TestRequestStringIpv4(ctx context.Context, request OptIPv4) (re return result, nil } -// TestRequestStringIpv4Array invokes test_request_string_ipv4_array operation. +// TestRequestStringPasswordNullableArray invokes test_request_string_password_nullable_array operation. // -// POST /test_request_string_ipv4_array -func (c *Client) TestRequestStringIpv4Array(ctx context.Context, request []netip.Addr) (res Error, err error) { +// POST /test_request_string_password_nullable_array +func (c *Client) TestRequestStringPasswordNullableArray(ctx context.Context, request []NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_array"), + otelogen.OperationID("test_request_string_password_nullable_array"), } // Validate request before sending. @@ -30662,7 +34691,7 @@ func (c *Client) TestRequestStringIpv4Array(ctx context.Context, request []netip c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30679,14 +34708,14 @@ func (c *Client) TestRequestStringIpv4Array(ctx context.Context, request []netip stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv4_array" + u.Path += "/test_request_string_password_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv4ArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringPasswordNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30698,7 +34727,7 @@ func (c *Client) TestRequestStringIpv4Array(ctx context.Context, request []netip defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv4ArrayResponse(resp, span) + result, err := decodeTestRequestStringPasswordNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30706,12 +34735,12 @@ func (c *Client) TestRequestStringIpv4Array(ctx context.Context, request []netip return result, nil } -// TestRequestStringIpv4ArrayArray invokes test_request_string_ipv4_array_array operation. +// TestRequestStringPasswordNullableArrayArray invokes test_request_string_password_nullable_array_array operation. // -// POST /test_request_string_ipv4_array_array -func (c *Client) TestRequestStringIpv4ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { +// POST /test_request_string_password_nullable_array_array +func (c *Client) TestRequestStringPasswordNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_array_array"), + otelogen.OperationID("test_request_string_password_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -30748,7 +34777,7 @@ func (c *Client) TestRequestStringIpv4ArrayArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30765,14 +34794,14 @@ func (c *Client) TestRequestStringIpv4ArrayArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv4_array_array" + u.Path += "/test_request_string_password_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv4ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringPasswordNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30784,7 +34813,7 @@ func (c *Client) TestRequestStringIpv4ArrayArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv4ArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringPasswordNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30792,12 +34821,12 @@ func (c *Client) TestRequestStringIpv4ArrayArray(ctx context.Context, request [] return result, nil } -// TestRequestStringIpv4Nullable invokes test_request_string_ipv4_nullable operation. +// TestRequestStringTime invokes test_request_string_time operation. // -// POST /test_request_string_ipv4_nullable -func (c *Client) TestRequestStringIpv4Nullable(ctx context.Context, request OptNilIPv4) (res Error, err error) { +// POST /test_request_string_time +func (c *Client) TestRequestStringTime(ctx context.Context, request OptTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable"), + otelogen.OperationID("test_request_string_time"), } // Validate request before sending. @@ -30812,7 +34841,7 @@ func (c *Client) TestRequestStringIpv4Nullable(ctx context.Context, request OptN c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTime", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30829,14 +34858,14 @@ func (c *Client) TestRequestStringIpv4Nullable(ctx context.Context, request OptN stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv4_nullable" + u.Path += "/test_request_string_time" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv4NullableRequest(request, r); err != nil { + if err := encodeTestRequestStringTimeRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30848,7 +34877,7 @@ func (c *Client) TestRequestStringIpv4Nullable(ctx context.Context, request OptN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv4NullableResponse(resp, span) + result, err := decodeTestRequestStringTimeResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30856,12 +34885,12 @@ func (c *Client) TestRequestStringIpv4Nullable(ctx context.Context, request OptN return result, nil } -// TestRequestStringIpv4NullableArray invokes test_request_string_ipv4_nullable_array operation. +// TestRequestStringTimeArray invokes test_request_string_time_array operation. // -// POST /test_request_string_ipv4_nullable_array -func (c *Client) TestRequestStringIpv4NullableArray(ctx context.Context, request []NilIPv4) (res Error, err error) { +// POST /test_request_string_time_array +func (c *Client) TestRequestStringTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable_array"), + otelogen.OperationID("test_request_string_time_array"), } // Validate request before sending. @@ -30876,7 +34905,7 @@ func (c *Client) TestRequestStringIpv4NullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30893,14 +34922,14 @@ func (c *Client) TestRequestStringIpv4NullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv4_nullable_array" + u.Path += "/test_request_string_time_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv4NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringTimeArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30912,7 +34941,7 @@ func (c *Client) TestRequestStringIpv4NullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv4NullableArrayResponse(resp, span) + result, err := decodeTestRequestStringTimeArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -30920,12 +34949,12 @@ func (c *Client) TestRequestStringIpv4NullableArray(ctx context.Context, request return result, nil } -// TestRequestStringIpv4NullableArrayArray invokes test_request_string_ipv4_nullable_array_array operation. +// TestRequestStringTimeArrayArray invokes test_request_string_time_array_array operation. // -// POST /test_request_string_ipv4_nullable_array_array -func (c *Client) TestRequestStringIpv4NullableArrayArray(ctx context.Context, request [][]NilIPv4) (res Error, err error) { +// POST /test_request_string_time_array_array +func (c *Client) TestRequestStringTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable_array_array"), + otelogen.OperationID("test_request_string_time_array_array"), } // Validate request before sending. if err := func() error { @@ -30962,7 +34991,7 @@ func (c *Client) TestRequestStringIpv4NullableArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv4NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -30979,14 +35008,14 @@ func (c *Client) TestRequestStringIpv4NullableArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv4_nullable_array_array" + u.Path += "/test_request_string_time_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv4NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringTimeArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -30998,7 +35027,7 @@ func (c *Client) TestRequestStringIpv4NullableArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv4NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringTimeArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31006,12 +35035,12 @@ func (c *Client) TestRequestStringIpv4NullableArrayArray(ctx context.Context, re return result, nil } -// TestRequestStringIpv6 invokes test_request_string_ipv6 operation. +// TestRequestStringTimeNullable invokes test_request_string_time_nullable operation. // -// POST /test_request_string_ipv6 -func (c *Client) TestRequestStringIpv6(ctx context.Context, request OptIPv6) (res Error, err error) { +// POST /test_request_string_time_nullable +func (c *Client) TestRequestStringTimeNullable(ctx context.Context, request OptNilTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6"), + otelogen.OperationID("test_request_string_time_nullable"), } // Validate request before sending. @@ -31026,7 +35055,7 @@ func (c *Client) TestRequestStringIpv6(ctx context.Context, request OptIPv6) (re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31043,14 +35072,14 @@ func (c *Client) TestRequestStringIpv6(ctx context.Context, request OptIPv6) (re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv6" + u.Path += "/test_request_string_time_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv6Request(request, r); err != nil { + if err := encodeTestRequestStringTimeNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31062,7 +35091,7 @@ func (c *Client) TestRequestStringIpv6(ctx context.Context, request OptIPv6) (re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv6Response(resp, span) + result, err := decodeTestRequestStringTimeNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31070,12 +35099,12 @@ func (c *Client) TestRequestStringIpv6(ctx context.Context, request OptIPv6) (re return result, nil } -// TestRequestStringIpv6Array invokes test_request_string_ipv6_array operation. +// TestRequestStringTimeNullableArray invokes test_request_string_time_nullable_array operation. // -// POST /test_request_string_ipv6_array -func (c *Client) TestRequestStringIpv6Array(ctx context.Context, request []netip.Addr) (res Error, err error) { +// POST /test_request_string_time_nullable_array +func (c *Client) TestRequestStringTimeNullableArray(ctx context.Context, request []NilTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_array"), + otelogen.OperationID("test_request_string_time_nullable_array"), } // Validate request before sending. @@ -31090,7 +35119,7 @@ func (c *Client) TestRequestStringIpv6Array(ctx context.Context, request []netip c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31107,14 +35136,14 @@ func (c *Client) TestRequestStringIpv6Array(ctx context.Context, request []netip stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv6_array" + u.Path += "/test_request_string_time_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv6ArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringTimeNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31126,7 +35155,7 @@ func (c *Client) TestRequestStringIpv6Array(ctx context.Context, request []netip defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv6ArrayResponse(resp, span) + result, err := decodeTestRequestStringTimeNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31134,12 +35163,12 @@ func (c *Client) TestRequestStringIpv6Array(ctx context.Context, request []netip return result, nil } -// TestRequestStringIpv6ArrayArray invokes test_request_string_ipv6_array_array operation. +// TestRequestStringTimeNullableArrayArray invokes test_request_string_time_nullable_array_array operation. // -// POST /test_request_string_ipv6_array_array -func (c *Client) TestRequestStringIpv6ArrayArray(ctx context.Context, request [][]netip.Addr) (res Error, err error) { +// POST /test_request_string_time_nullable_array_array +func (c *Client) TestRequestStringTimeNullableArrayArray(ctx context.Context, request [][]NilTime) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_array_array"), + otelogen.OperationID("test_request_string_time_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -31176,7 +35205,7 @@ func (c *Client) TestRequestStringIpv6ArrayArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31193,14 +35222,14 @@ func (c *Client) TestRequestStringIpv6ArrayArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv6_array_array" + u.Path += "/test_request_string_time_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv6ArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringTimeNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31212,7 +35241,7 @@ func (c *Client) TestRequestStringIpv6ArrayArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv6ArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringTimeNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31220,12 +35249,12 @@ func (c *Client) TestRequestStringIpv6ArrayArray(ctx context.Context, request [] return result, nil } -// TestRequestStringIpv6Nullable invokes test_request_string_ipv6_nullable operation. +// TestRequestStringURI invokes test_request_string_uri operation. // -// POST /test_request_string_ipv6_nullable -func (c *Client) TestRequestStringIpv6Nullable(ctx context.Context, request OptNilIPv6) (res Error, err error) { +// POST /test_request_string_uri +func (c *Client) TestRequestStringURI(ctx context.Context, request OptURI) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable"), + otelogen.OperationID("test_request_string_uri"), } // Validate request before sending. @@ -31240,7 +35269,7 @@ func (c *Client) TestRequestStringIpv6Nullable(ctx context.Context, request OptN c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURI", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31257,14 +35286,14 @@ func (c *Client) TestRequestStringIpv6Nullable(ctx context.Context, request OptN stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv6_nullable" + u.Path += "/test_request_string_uri" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv6NullableRequest(request, r); err != nil { + if err := encodeTestRequestStringURIRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31276,7 +35305,7 @@ func (c *Client) TestRequestStringIpv6Nullable(ctx context.Context, request OptN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv6NullableResponse(resp, span) + result, err := decodeTestRequestStringURIResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31284,12 +35313,12 @@ func (c *Client) TestRequestStringIpv6Nullable(ctx context.Context, request OptN return result, nil } -// TestRequestStringIpv6NullableArray invokes test_request_string_ipv6_nullable_array operation. +// TestRequestStringURIArray invokes test_request_string_uri_array operation. // -// POST /test_request_string_ipv6_nullable_array -func (c *Client) TestRequestStringIpv6NullableArray(ctx context.Context, request []NilIPv6) (res Error, err error) { +// POST /test_request_string_uri_array +func (c *Client) TestRequestStringURIArray(ctx context.Context, request []url.URL) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable_array"), + otelogen.OperationID("test_request_string_uri_array"), } // Validate request before sending. @@ -31304,7 +35333,7 @@ func (c *Client) TestRequestStringIpv6NullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURIArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31321,14 +35350,14 @@ func (c *Client) TestRequestStringIpv6NullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv6_nullable_array" + u.Path += "/test_request_string_uri_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv6NullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringURIArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31340,7 +35369,7 @@ func (c *Client) TestRequestStringIpv6NullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv6NullableArrayResponse(resp, span) + result, err := decodeTestRequestStringURIArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31348,12 +35377,12 @@ func (c *Client) TestRequestStringIpv6NullableArray(ctx context.Context, request return result, nil } -// TestRequestStringIpv6NullableArrayArray invokes test_request_string_ipv6_nullable_array_array operation. +// TestRequestStringURIArrayArray invokes test_request_string_uri_array_array operation. // -// POST /test_request_string_ipv6_nullable_array_array -func (c *Client) TestRequestStringIpv6NullableArrayArray(ctx context.Context, request [][]NilIPv6) (res Error, err error) { +// POST /test_request_string_uri_array_array +func (c *Client) TestRequestStringURIArrayArray(ctx context.Context, request [][]url.URL) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable_array_array"), + otelogen.OperationID("test_request_string_uri_array_array"), } // Validate request before sending. if err := func() error { @@ -31390,7 +35419,7 @@ func (c *Client) TestRequestStringIpv6NullableArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringIpv6NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURIArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31407,14 +35436,14 @@ func (c *Client) TestRequestStringIpv6NullableArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_ipv6_nullable_array_array" + u.Path += "/test_request_string_uri_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringIpv6NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringURIArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31426,7 +35455,7 @@ func (c *Client) TestRequestStringIpv6NullableArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringIpv6NullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringURIArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31434,12 +35463,12 @@ func (c *Client) TestRequestStringIpv6NullableArrayArray(ctx context.Context, re return result, nil } -// TestRequestStringNullable invokes test_request_string_nullable operation. +// TestRequestStringURINullable invokes test_request_string_uri_nullable operation. // -// POST /test_request_string_nullable -func (c *Client) TestRequestStringNullable(ctx context.Context, request OptNilString) (res Error, err error) { +// POST /test_request_string_uri_nullable +func (c *Client) TestRequestStringURINullable(ctx context.Context, request OptNilURI) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable"), + otelogen.OperationID("test_request_string_uri_nullable"), } // Validate request before sending. @@ -31454,7 +35483,7 @@ func (c *Client) TestRequestStringNullable(ctx context.Context, request OptNilSt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURINullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31471,14 +35500,14 @@ func (c *Client) TestRequestStringNullable(ctx context.Context, request OptNilSt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_nullable" + u.Path += "/test_request_string_uri_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringURINullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31490,7 +35519,7 @@ func (c *Client) TestRequestStringNullable(ctx context.Context, request OptNilSt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringNullableResponse(resp, span) + result, err := decodeTestRequestStringURINullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31498,12 +35527,12 @@ func (c *Client) TestRequestStringNullable(ctx context.Context, request OptNilSt return result, nil } -// TestRequestStringNullableArray invokes test_request_string_nullable_array operation. +// TestRequestStringURINullableArray invokes test_request_string_uri_nullable_array operation. // -// POST /test_request_string_nullable_array -func (c *Client) TestRequestStringNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_string_uri_nullable_array +func (c *Client) TestRequestStringURINullableArray(ctx context.Context, request []NilURI) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable_array"), + otelogen.OperationID("test_request_string_uri_nullable_array"), } // Validate request before sending. @@ -31518,7 +35547,7 @@ func (c *Client) TestRequestStringNullableArray(ctx context.Context, request []N c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURINullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31535,14 +35564,14 @@ func (c *Client) TestRequestStringNullableArray(ctx context.Context, request []N stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_nullable_array" + u.Path += "/test_request_string_uri_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringURINullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31554,7 +35583,7 @@ func (c *Client) TestRequestStringNullableArray(ctx context.Context, request []N defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringURINullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31562,12 +35591,12 @@ func (c *Client) TestRequestStringNullableArray(ctx context.Context, request []N return result, nil } -// TestRequestStringNullableArrayArray invokes test_request_string_nullable_array_array operation. +// TestRequestStringURINullableArrayArray invokes test_request_string_uri_nullable_array_array operation. // -// POST /test_request_string_nullable_array_array -func (c *Client) TestRequestStringNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_string_uri_nullable_array_array +func (c *Client) TestRequestStringURINullableArrayArray(ctx context.Context, request [][]NilURI) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable_array_array"), + otelogen.OperationID("test_request_string_uri_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -31604,7 +35633,7 @@ func (c *Client) TestRequestStringNullableArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURINullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31621,14 +35650,14 @@ func (c *Client) TestRequestStringNullableArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_nullable_array_array" + u.Path += "/test_request_string_uri_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringURINullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31640,7 +35669,7 @@ func (c *Client) TestRequestStringNullableArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringURINullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31648,12 +35677,12 @@ func (c *Client) TestRequestStringNullableArrayArray(ctx context.Context, reques return result, nil } -// TestRequestStringPassword invokes test_request_string_password operation. +// TestRequestStringUUID invokes test_request_string_uuid operation. // -// POST /test_request_string_password -func (c *Client) TestRequestStringPassword(ctx context.Context, request OptString) (res Error, err error) { +// POST /test_request_string_uuid +func (c *Client) TestRequestStringUUID(ctx context.Context, request OptUUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password"), + otelogen.OperationID("test_request_string_uuid"), } // Validate request before sending. @@ -31668,7 +35697,7 @@ func (c *Client) TestRequestStringPassword(ctx context.Context, request OptStrin c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPassword", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUID", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31685,14 +35714,14 @@ func (c *Client) TestRequestStringPassword(ctx context.Context, request OptStrin stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_password" + u.Path += "/test_request_string_uuid" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringPasswordRequest(request, r); err != nil { + if err := encodeTestRequestStringUUIDRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31704,7 +35733,7 @@ func (c *Client) TestRequestStringPassword(ctx context.Context, request OptStrin defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringPasswordResponse(resp, span) + result, err := decodeTestRequestStringUUIDResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31712,12 +35741,12 @@ func (c *Client) TestRequestStringPassword(ctx context.Context, request OptStrin return result, nil } -// TestRequestStringPasswordArray invokes test_request_string_password_array operation. +// TestRequestStringUUIDArray invokes test_request_string_uuid_array operation. // -// POST /test_request_string_password_array -func (c *Client) TestRequestStringPasswordArray(ctx context.Context, request []string) (res Error, err error) { +// POST /test_request_string_uuid_array +func (c *Client) TestRequestStringUUIDArray(ctx context.Context, request []uuid.UUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_array"), + otelogen.OperationID("test_request_string_uuid_array"), } // Validate request before sending. @@ -31732,7 +35761,7 @@ func (c *Client) TestRequestStringPasswordArray(ctx context.Context, request []s c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31749,14 +35778,14 @@ func (c *Client) TestRequestStringPasswordArray(ctx context.Context, request []s stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_password_array" + u.Path += "/test_request_string_uuid_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringPasswordArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUUIDArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31768,7 +35797,7 @@ func (c *Client) TestRequestStringPasswordArray(ctx context.Context, request []s defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringPasswordArrayResponse(resp, span) + result, err := decodeTestRequestStringUUIDArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31776,12 +35805,12 @@ func (c *Client) TestRequestStringPasswordArray(ctx context.Context, request []s return result, nil } -// TestRequestStringPasswordArrayArray invokes test_request_string_password_array_array operation. +// TestRequestStringUUIDArrayArray invokes test_request_string_uuid_array_array operation. // -// POST /test_request_string_password_array_array -func (c *Client) TestRequestStringPasswordArrayArray(ctx context.Context, request [][]string) (res Error, err error) { +// POST /test_request_string_uuid_array_array +func (c *Client) TestRequestStringUUIDArrayArray(ctx context.Context, request [][]uuid.UUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_array_array"), + otelogen.OperationID("test_request_string_uuid_array_array"), } // Validate request before sending. if err := func() error { @@ -31818,7 +35847,7 @@ func (c *Client) TestRequestStringPasswordArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31835,14 +35864,14 @@ func (c *Client) TestRequestStringPasswordArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_password_array_array" + u.Path += "/test_request_string_uuid_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringPasswordArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUUIDArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31854,7 +35883,7 @@ func (c *Client) TestRequestStringPasswordArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringPasswordArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUUIDArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31862,12 +35891,12 @@ func (c *Client) TestRequestStringPasswordArrayArray(ctx context.Context, reques return result, nil } -// TestRequestStringPasswordNullable invokes test_request_string_password_nullable operation. +// TestRequestStringUUIDNullable invokes test_request_string_uuid_nullable operation. // -// POST /test_request_string_password_nullable -func (c *Client) TestRequestStringPasswordNullable(ctx context.Context, request OptNilString) (res Error, err error) { +// POST /test_request_string_uuid_nullable +func (c *Client) TestRequestStringUUIDNullable(ctx context.Context, request OptNilUUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable"), + otelogen.OperationID("test_request_string_uuid_nullable"), } // Validate request before sending. @@ -31882,7 +35911,7 @@ func (c *Client) TestRequestStringPasswordNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31899,14 +35928,14 @@ func (c *Client) TestRequestStringPasswordNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_password_nullable" + u.Path += "/test_request_string_uuid_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringPasswordNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringUUIDNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31918,7 +35947,7 @@ func (c *Client) TestRequestStringPasswordNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringPasswordNullableResponse(resp, span) + result, err := decodeTestRequestStringUUIDNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31926,12 +35955,12 @@ func (c *Client) TestRequestStringPasswordNullable(ctx context.Context, request return result, nil } -// TestRequestStringPasswordNullableArray invokes test_request_string_password_nullable_array operation. +// TestRequestStringUUIDNullableArray invokes test_request_string_uuid_nullable_array operation. // -// POST /test_request_string_password_nullable_array -func (c *Client) TestRequestStringPasswordNullableArray(ctx context.Context, request []NilString) (res Error, err error) { +// POST /test_request_string_uuid_nullable_array +func (c *Client) TestRequestStringUUIDNullableArray(ctx context.Context, request []NilUUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable_array"), + otelogen.OperationID("test_request_string_uuid_nullable_array"), } // Validate request before sending. @@ -31946,7 +35975,7 @@ func (c *Client) TestRequestStringPasswordNullableArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -31963,14 +35992,14 @@ func (c *Client) TestRequestStringPasswordNullableArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_password_nullable_array" + u.Path += "/test_request_string_uuid_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringPasswordNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUUIDNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -31982,7 +36011,7 @@ func (c *Client) TestRequestStringPasswordNullableArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringPasswordNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringUUIDNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -31990,12 +36019,12 @@ func (c *Client) TestRequestStringPasswordNullableArray(ctx context.Context, req return result, nil } -// TestRequestStringPasswordNullableArrayArray invokes test_request_string_password_nullable_array_array operation. +// TestRequestStringUUIDNullableArrayArray invokes test_request_string_uuid_nullable_array_array operation. // -// POST /test_request_string_password_nullable_array_array -func (c *Client) TestRequestStringPasswordNullableArrayArray(ctx context.Context, request [][]NilString) (res Error, err error) { +// POST /test_request_string_uuid_nullable_array_array +func (c *Client) TestRequestStringUUIDNullableArrayArray(ctx context.Context, request [][]NilUUID) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable_array_array"), + otelogen.OperationID("test_request_string_uuid_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -32032,7 +36061,7 @@ func (c *Client) TestRequestStringPasswordNullableArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringPasswordNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32049,14 +36078,14 @@ func (c *Client) TestRequestStringPasswordNullableArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_password_nullable_array_array" + u.Path += "/test_request_string_uuid_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringPasswordNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUUIDNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32068,7 +36097,7 @@ func (c *Client) TestRequestStringPasswordNullableArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringPasswordNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUUIDNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32076,12 +36105,12 @@ func (c *Client) TestRequestStringPasswordNullableArrayArray(ctx context.Context return result, nil } -// TestRequestStringTime invokes test_request_string_time operation. +// TestRequestStringUnix invokes test_request_string_unix operation. // -// POST /test_request_string_time -func (c *Client) TestRequestStringTime(ctx context.Context, request OptTime) (res Error, err error) { +// POST /test_request_string_unix +func (c *Client) TestRequestStringUnix(ctx context.Context, request OptStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time"), + otelogen.OperationID("test_request_string_unix"), } // Validate request before sending. @@ -32096,7 +36125,7 @@ func (c *Client) TestRequestStringTime(ctx context.Context, request OptTime) (re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTime", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnix", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32113,14 +36142,14 @@ func (c *Client) TestRequestStringTime(ctx context.Context, request OptTime) (re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_time" + u.Path += "/test_request_string_unix" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringTimeRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32132,7 +36161,7 @@ func (c *Client) TestRequestStringTime(ctx context.Context, request OptTime) (re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringTimeResponse(resp, span) + result, err := decodeTestRequestStringUnixResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32140,12 +36169,12 @@ func (c *Client) TestRequestStringTime(ctx context.Context, request OptTime) (re return result, nil } -// TestRequestStringTimeArray invokes test_request_string_time_array operation. +// TestRequestStringUnixArray invokes test_request_string_unix_array operation. // -// POST /test_request_string_time_array -func (c *Client) TestRequestStringTimeArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_string_unix_array +func (c *Client) TestRequestStringUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_array"), + otelogen.OperationID("test_request_string_unix_array"), } // Validate request before sending. @@ -32160,7 +36189,7 @@ func (c *Client) TestRequestStringTimeArray(ctx context.Context, request []time. c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32177,14 +36206,14 @@ func (c *Client) TestRequestStringTimeArray(ctx context.Context, request []time. stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_time_array" + u.Path += "/test_request_string_unix_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringTimeArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32196,7 +36225,7 @@ func (c *Client) TestRequestStringTimeArray(ctx context.Context, request []time. defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringTimeArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32204,12 +36233,12 @@ func (c *Client) TestRequestStringTimeArray(ctx context.Context, request []time. return result, nil } -// TestRequestStringTimeArrayArray invokes test_request_string_time_array_array operation. +// TestRequestStringUnixArrayArray invokes test_request_string_unix_array_array operation. // -// POST /test_request_string_time_array_array -func (c *Client) TestRequestStringTimeArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_string_unix_array_array +func (c *Client) TestRequestStringUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_array_array"), + otelogen.OperationID("test_request_string_unix_array_array"), } // Validate request before sending. if err := func() error { @@ -32246,7 +36275,7 @@ func (c *Client) TestRequestStringTimeArrayArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32263,14 +36292,14 @@ func (c *Client) TestRequestStringTimeArrayArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_time_array_array" + u.Path += "/test_request_string_unix_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringTimeArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32282,7 +36311,7 @@ func (c *Client) TestRequestStringTimeArrayArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringTimeArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32290,12 +36319,12 @@ func (c *Client) TestRequestStringTimeArrayArray(ctx context.Context, request [] return result, nil } -// TestRequestStringTimeNullable invokes test_request_string_time_nullable operation. +// TestRequestStringUnixMicro invokes test_request_string_unix-micro operation. // -// POST /test_request_string_time_nullable -func (c *Client) TestRequestStringTimeNullable(ctx context.Context, request OptNilTime) (res Error, err error) { +// POST /test_request_string_unix-micro +func (c *Client) TestRequestStringUnixMicro(ctx context.Context, request OptStringUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable"), + otelogen.OperationID("test_request_string_unix-micro"), } // Validate request before sending. @@ -32310,7 +36339,7 @@ func (c *Client) TestRequestStringTimeNullable(ctx context.Context, request OptN c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicro", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32327,14 +36356,14 @@ func (c *Client) TestRequestStringTimeNullable(ctx context.Context, request OptN stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_time_nullable" + u.Path += "/test_request_string_unix-micro" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringTimeNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMicroRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32346,7 +36375,7 @@ func (c *Client) TestRequestStringTimeNullable(ctx context.Context, request OptN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringTimeNullableResponse(resp, span) + result, err := decodeTestRequestStringUnixMicroResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32354,12 +36383,12 @@ func (c *Client) TestRequestStringTimeNullable(ctx context.Context, request OptN return result, nil } -// TestRequestStringTimeNullableArray invokes test_request_string_time_nullable_array operation. +// TestRequestStringUnixMicroArray invokes test_request_string_unix-micro_array operation. // -// POST /test_request_string_time_nullable_array -func (c *Client) TestRequestStringTimeNullableArray(ctx context.Context, request []NilTime) (res Error, err error) { +// POST /test_request_string_unix-micro_array +func (c *Client) TestRequestStringUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable_array"), + otelogen.OperationID("test_request_string_unix-micro_array"), } // Validate request before sending. @@ -32374,7 +36403,7 @@ func (c *Client) TestRequestStringTimeNullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32391,14 +36420,14 @@ func (c *Client) TestRequestStringTimeNullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_time_nullable_array" + u.Path += "/test_request_string_unix-micro_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringTimeNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMicroArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32410,7 +36439,7 @@ func (c *Client) TestRequestStringTimeNullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringTimeNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMicroArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32418,12 +36447,12 @@ func (c *Client) TestRequestStringTimeNullableArray(ctx context.Context, request return result, nil } -// TestRequestStringTimeNullableArrayArray invokes test_request_string_time_nullable_array_array operation. +// TestRequestStringUnixMicroArrayArray invokes test_request_string_unix-micro_array_array operation. // -// POST /test_request_string_time_nullable_array_array -func (c *Client) TestRequestStringTimeNullableArrayArray(ctx context.Context, request [][]NilTime) (res Error, err error) { +// POST /test_request_string_unix-micro_array_array +func (c *Client) TestRequestStringUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-micro_array_array"), } // Validate request before sending. if err := func() error { @@ -32460,7 +36489,7 @@ func (c *Client) TestRequestStringTimeNullableArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringTimeNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32477,14 +36506,14 @@ func (c *Client) TestRequestStringTimeNullableArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_time_nullable_array_array" + u.Path += "/test_request_string_unix-micro_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringTimeNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMicroArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32496,7 +36525,7 @@ func (c *Client) TestRequestStringTimeNullableArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringTimeNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMicroArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32504,12 +36533,12 @@ func (c *Client) TestRequestStringTimeNullableArrayArray(ctx context.Context, re return result, nil } -// TestRequestStringURI invokes test_request_string_uri operation. +// TestRequestStringUnixMicroNullable invokes test_request_string_unix-micro_nullable operation. // -// POST /test_request_string_uri -func (c *Client) TestRequestStringURI(ctx context.Context, request OptURI) (res Error, err error) { +// POST /test_request_string_unix-micro_nullable +func (c *Client) TestRequestStringUnixMicroNullable(ctx context.Context, request OptNilStringUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri"), + otelogen.OperationID("test_request_string_unix-micro_nullable"), } // Validate request before sending. @@ -32524,7 +36553,7 @@ func (c *Client) TestRequestStringURI(ctx context.Context, request OptURI) (res c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURI", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32541,14 +36570,14 @@ func (c *Client) TestRequestStringURI(ctx context.Context, request OptURI) (res stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uri" + u.Path += "/test_request_string_unix-micro_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringURIRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMicroNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32560,7 +36589,7 @@ func (c *Client) TestRequestStringURI(ctx context.Context, request OptURI) (res defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringURIResponse(resp, span) + result, err := decodeTestRequestStringUnixMicroNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32568,12 +36597,12 @@ func (c *Client) TestRequestStringURI(ctx context.Context, request OptURI) (res return result, nil } -// TestRequestStringURIArray invokes test_request_string_uri_array operation. +// TestRequestStringUnixMicroNullableArray invokes test_request_string_unix-micro_nullable_array operation. // -// POST /test_request_string_uri_array -func (c *Client) TestRequestStringURIArray(ctx context.Context, request []url.URL) (res Error, err error) { +// POST /test_request_string_unix-micro_nullable_array +func (c *Client) TestRequestStringUnixMicroNullableArray(ctx context.Context, request []NilStringUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_array"), + otelogen.OperationID("test_request_string_unix-micro_nullable_array"), } // Validate request before sending. @@ -32588,7 +36617,7 @@ func (c *Client) TestRequestStringURIArray(ctx context.Context, request []url.UR c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURIArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32605,14 +36634,14 @@ func (c *Client) TestRequestStringURIArray(ctx context.Context, request []url.UR stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uri_array" + u.Path += "/test_request_string_unix-micro_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringURIArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMicroNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32624,7 +36653,7 @@ func (c *Client) TestRequestStringURIArray(ctx context.Context, request []url.UR defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringURIArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMicroNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32632,12 +36661,12 @@ func (c *Client) TestRequestStringURIArray(ctx context.Context, request []url.UR return result, nil } -// TestRequestStringURIArrayArray invokes test_request_string_uri_array_array operation. +// TestRequestStringUnixMicroNullableArrayArray invokes test_request_string_unix-micro_nullable_array_array operation. // -// POST /test_request_string_uri_array_array -func (c *Client) TestRequestStringURIArrayArray(ctx context.Context, request [][]url.URL) (res Error, err error) { +// POST /test_request_string_unix-micro_nullable_array_array +func (c *Client) TestRequestStringUnixMicroNullableArrayArray(ctx context.Context, request [][]NilStringUnixMicro) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_array_array"), + otelogen.OperationID("test_request_string_unix-micro_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -32674,7 +36703,7 @@ func (c *Client) TestRequestStringURIArrayArray(ctx context.Context, request [][ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURIArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32691,14 +36720,14 @@ func (c *Client) TestRequestStringURIArrayArray(ctx context.Context, request [][ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uri_array_array" + u.Path += "/test_request_string_unix-micro_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringURIArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMicroNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32710,7 +36739,7 @@ func (c *Client) TestRequestStringURIArrayArray(ctx context.Context, request [][ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringURIArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32718,12 +36747,12 @@ func (c *Client) TestRequestStringURIArrayArray(ctx context.Context, request [][ return result, nil } -// TestRequestStringURINullable invokes test_request_string_uri_nullable operation. +// TestRequestStringUnixMilli invokes test_request_string_unix-milli operation. // -// POST /test_request_string_uri_nullable -func (c *Client) TestRequestStringURINullable(ctx context.Context, request OptNilURI) (res Error, err error) { +// POST /test_request_string_unix-milli +func (c *Client) TestRequestStringUnixMilli(ctx context.Context, request OptStringUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable"), + otelogen.OperationID("test_request_string_unix-milli"), } // Validate request before sending. @@ -32738,7 +36767,7 @@ func (c *Client) TestRequestStringURINullable(ctx context.Context, request OptNi c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURINullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilli", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32755,14 +36784,14 @@ func (c *Client) TestRequestStringURINullable(ctx context.Context, request OptNi stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uri_nullable" + u.Path += "/test_request_string_unix-milli" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringURINullableRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMilliRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32774,7 +36803,7 @@ func (c *Client) TestRequestStringURINullable(ctx context.Context, request OptNi defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringURINullableResponse(resp, span) + result, err := decodeTestRequestStringUnixMilliResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32782,12 +36811,12 @@ func (c *Client) TestRequestStringURINullable(ctx context.Context, request OptNi return result, nil } -// TestRequestStringURINullableArray invokes test_request_string_uri_nullable_array operation. +// TestRequestStringUnixMilliArray invokes test_request_string_unix-milli_array operation. // -// POST /test_request_string_uri_nullable_array -func (c *Client) TestRequestStringURINullableArray(ctx context.Context, request []NilURI) (res Error, err error) { +// POST /test_request_string_unix-milli_array +func (c *Client) TestRequestStringUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable_array"), + otelogen.OperationID("test_request_string_unix-milli_array"), } // Validate request before sending. @@ -32802,7 +36831,7 @@ func (c *Client) TestRequestStringURINullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURINullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32819,14 +36848,14 @@ func (c *Client) TestRequestStringURINullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uri_nullable_array" + u.Path += "/test_request_string_unix-milli_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringURINullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMilliArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32838,7 +36867,7 @@ func (c *Client) TestRequestStringURINullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringURINullableArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMilliArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32846,12 +36875,12 @@ func (c *Client) TestRequestStringURINullableArray(ctx context.Context, request return result, nil } -// TestRequestStringURINullableArrayArray invokes test_request_string_uri_nullable_array_array operation. +// TestRequestStringUnixMilliArrayArray invokes test_request_string_unix-milli_array_array operation. // -// POST /test_request_string_uri_nullable_array_array -func (c *Client) TestRequestStringURINullableArrayArray(ctx context.Context, request [][]NilURI) (res Error, err error) { +// POST /test_request_string_unix-milli_array_array +func (c *Client) TestRequestStringUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-milli_array_array"), } // Validate request before sending. if err := func() error { @@ -32888,7 +36917,7 @@ func (c *Client) TestRequestStringURINullableArrayArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringURINullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32905,14 +36934,14 @@ func (c *Client) TestRequestStringURINullableArrayArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uri_nullable_array_array" + u.Path += "/test_request_string_unix-milli_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringURINullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMilliArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32924,7 +36953,7 @@ func (c *Client) TestRequestStringURINullableArrayArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringURINullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMilliArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32932,12 +36961,12 @@ func (c *Client) TestRequestStringURINullableArrayArray(ctx context.Context, req return result, nil } -// TestRequestStringUUID invokes test_request_string_uuid operation. +// TestRequestStringUnixMilliNullable invokes test_request_string_unix-milli_nullable operation. // -// POST /test_request_string_uuid -func (c *Client) TestRequestStringUUID(ctx context.Context, request OptUUID) (res Error, err error) { +// POST /test_request_string_unix-milli_nullable +func (c *Client) TestRequestStringUnixMilliNullable(ctx context.Context, request OptNilStringUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid"), + otelogen.OperationID("test_request_string_unix-milli_nullable"), } // Validate request before sending. @@ -32952,7 +36981,7 @@ func (c *Client) TestRequestStringUUID(ctx context.Context, request OptUUID) (re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUID", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -32969,14 +36998,14 @@ func (c *Client) TestRequestStringUUID(ctx context.Context, request OptUUID) (re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uuid" + u.Path += "/test_request_string_unix-milli_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUUIDRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMilliNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -32988,7 +37017,7 @@ func (c *Client) TestRequestStringUUID(ctx context.Context, request OptUUID) (re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUUIDResponse(resp, span) + result, err := decodeTestRequestStringUnixMilliNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -32996,12 +37025,12 @@ func (c *Client) TestRequestStringUUID(ctx context.Context, request OptUUID) (re return result, nil } -// TestRequestStringUUIDArray invokes test_request_string_uuid_array operation. +// TestRequestStringUnixMilliNullableArray invokes test_request_string_unix-milli_nullable_array operation. // -// POST /test_request_string_uuid_array -func (c *Client) TestRequestStringUUIDArray(ctx context.Context, request []uuid.UUID) (res Error, err error) { +// POST /test_request_string_unix-milli_nullable_array +func (c *Client) TestRequestStringUnixMilliNullableArray(ctx context.Context, request []NilStringUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_array"), + otelogen.OperationID("test_request_string_unix-milli_nullable_array"), } // Validate request before sending. @@ -33016,7 +37045,7 @@ func (c *Client) TestRequestStringUUIDArray(ctx context.Context, request []uuid. c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33033,14 +37062,14 @@ func (c *Client) TestRequestStringUUIDArray(ctx context.Context, request []uuid. stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uuid_array" + u.Path += "/test_request_string_unix-milli_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUUIDArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMilliNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33052,7 +37081,7 @@ func (c *Client) TestRequestStringUUIDArray(ctx context.Context, request []uuid. defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUUIDArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMilliNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33060,12 +37089,12 @@ func (c *Client) TestRequestStringUUIDArray(ctx context.Context, request []uuid. return result, nil } -// TestRequestStringUUIDArrayArray invokes test_request_string_uuid_array_array operation. +// TestRequestStringUnixMilliNullableArrayArray invokes test_request_string_unix-milli_nullable_array_array operation. // -// POST /test_request_string_uuid_array_array -func (c *Client) TestRequestStringUUIDArrayArray(ctx context.Context, request [][]uuid.UUID) (res Error, err error) { +// POST /test_request_string_unix-milli_nullable_array_array +func (c *Client) TestRequestStringUnixMilliNullableArrayArray(ctx context.Context, request [][]NilStringUnixMilli) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_array_array"), + otelogen.OperationID("test_request_string_unix-milli_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -33102,7 +37131,7 @@ func (c *Client) TestRequestStringUUIDArrayArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33119,14 +37148,14 @@ func (c *Client) TestRequestStringUUIDArrayArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uuid_array_array" + u.Path += "/test_request_string_unix-milli_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUUIDArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixMilliNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33138,7 +37167,7 @@ func (c *Client) TestRequestStringUUIDArrayArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUUIDArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33146,12 +37175,12 @@ func (c *Client) TestRequestStringUUIDArrayArray(ctx context.Context, request [] return result, nil } -// TestRequestStringUUIDNullable invokes test_request_string_uuid_nullable operation. +// TestRequestStringUnixNano invokes test_request_string_unix-nano operation. // -// POST /test_request_string_uuid_nullable -func (c *Client) TestRequestStringUUIDNullable(ctx context.Context, request OptNilUUID) (res Error, err error) { +// POST /test_request_string_unix-nano +func (c *Client) TestRequestStringUnixNano(ctx context.Context, request OptStringUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable"), + otelogen.OperationID("test_request_string_unix-nano"), } // Validate request before sending. @@ -33166,7 +37195,7 @@ func (c *Client) TestRequestStringUUIDNullable(ctx context.Context, request OptN c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNano", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33183,14 +37212,14 @@ func (c *Client) TestRequestStringUUIDNullable(ctx context.Context, request OptN stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uuid_nullable" + u.Path += "/test_request_string_unix-nano" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUUIDNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNanoRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33202,7 +37231,7 @@ func (c *Client) TestRequestStringUUIDNullable(ctx context.Context, request OptN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUUIDNullableResponse(resp, span) + result, err := decodeTestRequestStringUnixNanoResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33210,12 +37239,12 @@ func (c *Client) TestRequestStringUUIDNullable(ctx context.Context, request OptN return result, nil } -// TestRequestStringUUIDNullableArray invokes test_request_string_uuid_nullable_array operation. +// TestRequestStringUnixNanoArray invokes test_request_string_unix-nano_array operation. // -// POST /test_request_string_uuid_nullable_array -func (c *Client) TestRequestStringUUIDNullableArray(ctx context.Context, request []NilUUID) (res Error, err error) { +// POST /test_request_string_unix-nano_array +func (c *Client) TestRequestStringUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable_array"), + otelogen.OperationID("test_request_string_unix-nano_array"), } // Validate request before sending. @@ -33230,7 +37259,7 @@ func (c *Client) TestRequestStringUUIDNullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33247,14 +37276,14 @@ func (c *Client) TestRequestStringUUIDNullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uuid_nullable_array" + u.Path += "/test_request_string_unix-nano_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUUIDNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNanoArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33266,7 +37295,7 @@ func (c *Client) TestRequestStringUUIDNullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUUIDNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixNanoArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33274,12 +37303,12 @@ func (c *Client) TestRequestStringUUIDNullableArray(ctx context.Context, request return result, nil } -// TestRequestStringUUIDNullableArrayArray invokes test_request_string_uuid_nullable_array_array operation. +// TestRequestStringUnixNanoArrayArray invokes test_request_string_unix-nano_array_array operation. // -// POST /test_request_string_uuid_nullable_array_array -func (c *Client) TestRequestStringUUIDNullableArrayArray(ctx context.Context, request [][]NilUUID) (res Error, err error) { +// POST /test_request_string_unix-nano_array_array +func (c *Client) TestRequestStringUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-nano_array_array"), } // Validate request before sending. if err := func() error { @@ -33316,7 +37345,7 @@ func (c *Client) TestRequestStringUUIDNullableArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUUIDNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33333,14 +37362,14 @@ func (c *Client) TestRequestStringUUIDNullableArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_uuid_nullable_array_array" + u.Path += "/test_request_string_unix-nano_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUUIDNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNanoArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33352,7 +37381,7 @@ func (c *Client) TestRequestStringUUIDNullableArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUUIDNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixNanoArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33360,12 +37389,12 @@ func (c *Client) TestRequestStringUUIDNullableArrayArray(ctx context.Context, re return result, nil } -// TestRequestStringUnix invokes test_request_string_unix operation. +// TestRequestStringUnixNanoNullable invokes test_request_string_unix-nano_nullable operation. // -// POST /test_request_string_unix -func (c *Client) TestRequestStringUnix(ctx context.Context, request OptStringUnixSeconds) (res Error, err error) { +// POST /test_request_string_unix-nano_nullable +func (c *Client) TestRequestStringUnixNanoNullable(ctx context.Context, request OptNilStringUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix"), + otelogen.OperationID("test_request_string_unix-nano_nullable"), } // Validate request before sending. @@ -33380,7 +37409,7 @@ func (c *Client) TestRequestStringUnix(ctx context.Context, request OptStringUni c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnix", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33397,14 +37426,14 @@ func (c *Client) TestRequestStringUnix(ctx context.Context, request OptStringUni stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix" + u.Path += "/test_request_string_unix-nano_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNanoNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33416,7 +37445,7 @@ func (c *Client) TestRequestStringUnix(ctx context.Context, request OptStringUni defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixResponse(resp, span) + result, err := decodeTestRequestStringUnixNanoNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33424,12 +37453,12 @@ func (c *Client) TestRequestStringUnix(ctx context.Context, request OptStringUni return result, nil } -// TestRequestStringUnixArray invokes test_request_string_unix_array operation. +// TestRequestStringUnixNanoNullableArray invokes test_request_string_unix-nano_nullable_array operation. // -// POST /test_request_string_unix_array -func (c *Client) TestRequestStringUnixArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_string_unix-nano_nullable_array +func (c *Client) TestRequestStringUnixNanoNullableArray(ctx context.Context, request []NilStringUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_array"), + otelogen.OperationID("test_request_string_unix-nano_nullable_array"), } // Validate request before sending. @@ -33444,7 +37473,7 @@ func (c *Client) TestRequestStringUnixArray(ctx context.Context, request []time. c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33461,14 +37490,14 @@ func (c *Client) TestRequestStringUnixArray(ctx context.Context, request []time. stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix_array" + u.Path += "/test_request_string_unix-nano_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNanoNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33480,7 +37509,7 @@ func (c *Client) TestRequestStringUnixArray(ctx context.Context, request []time. defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixNanoNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33488,12 +37517,12 @@ func (c *Client) TestRequestStringUnixArray(ctx context.Context, request []time. return result, nil } -// TestRequestStringUnixArrayArray invokes test_request_string_unix_array_array operation. +// TestRequestStringUnixNanoNullableArrayArray invokes test_request_string_unix-nano_nullable_array_array operation. // -// POST /test_request_string_unix_array_array -func (c *Client) TestRequestStringUnixArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_string_unix-nano_nullable_array_array +func (c *Client) TestRequestStringUnixNanoNullableArrayArray(ctx context.Context, request [][]NilStringUnixNano) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_array_array"), + otelogen.OperationID("test_request_string_unix-nano_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -33530,7 +37559,7 @@ func (c *Client) TestRequestStringUnixArrayArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33547,14 +37576,14 @@ func (c *Client) TestRequestStringUnixArrayArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix_array_array" + u.Path += "/test_request_string_unix-nano_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNanoNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33566,7 +37595,7 @@ func (c *Client) TestRequestStringUnixArrayArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33574,12 +37603,12 @@ func (c *Client) TestRequestStringUnixArrayArray(ctx context.Context, request [] return result, nil } -// TestRequestStringUnixMicro invokes test_request_string_unix-micro operation. +// TestRequestStringUnixNullable invokes test_request_string_unix_nullable operation. // -// POST /test_request_string_unix-micro -func (c *Client) TestRequestStringUnixMicro(ctx context.Context, request OptStringUnixMicro) (res Error, err error) { +// POST /test_request_string_unix_nullable +func (c *Client) TestRequestStringUnixNullable(ctx context.Context, request OptNilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro"), + otelogen.OperationID("test_request_string_unix_nullable"), } // Validate request before sending. @@ -33594,7 +37623,7 @@ func (c *Client) TestRequestStringUnixMicro(ctx context.Context, request OptStri c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicro", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33611,14 +37640,14 @@ func (c *Client) TestRequestStringUnixMicro(ctx context.Context, request OptStri stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-micro" + u.Path += "/test_request_string_unix_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMicroRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33630,7 +37659,7 @@ func (c *Client) TestRequestStringUnixMicro(ctx context.Context, request OptStri defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMicroResponse(resp, span) + result, err := decodeTestRequestStringUnixNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33638,12 +37667,12 @@ func (c *Client) TestRequestStringUnixMicro(ctx context.Context, request OptStri return result, nil } -// TestRequestStringUnixMicroArray invokes test_request_string_unix-micro_array operation. +// TestRequestStringUnixNullableArray invokes test_request_string_unix_nullable_array operation. // -// POST /test_request_string_unix-micro_array -func (c *Client) TestRequestStringUnixMicroArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_string_unix_nullable_array +func (c *Client) TestRequestStringUnixNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_array"), + otelogen.OperationID("test_request_string_unix_nullable_array"), } // Validate request before sending. @@ -33658,7 +37687,7 @@ func (c *Client) TestRequestStringUnixMicroArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33675,14 +37704,14 @@ func (c *Client) TestRequestStringUnixMicroArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-micro_array" + u.Path += "/test_request_string_unix_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMicroArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33694,7 +37723,7 @@ func (c *Client) TestRequestStringUnixMicroArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMicroArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33702,12 +37731,12 @@ func (c *Client) TestRequestStringUnixMicroArray(ctx context.Context, request [] return result, nil } -// TestRequestStringUnixMicroArrayArray invokes test_request_string_unix-micro_array_array operation. +// TestRequestStringUnixNullableArrayArray invokes test_request_string_unix_nullable_array_array operation. // -// POST /test_request_string_unix-micro_array_array -func (c *Client) TestRequestStringUnixMicroArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_string_unix_nullable_array_array +func (c *Client) TestRequestStringUnixNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_array_array"), + otelogen.OperationID("test_request_string_unix_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -33744,7 +37773,7 @@ func (c *Client) TestRequestStringUnixMicroArrayArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33761,14 +37790,14 @@ func (c *Client) TestRequestStringUnixMicroArrayArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-micro_array_array" + u.Path += "/test_request_string_unix_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMicroArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33780,7 +37809,7 @@ func (c *Client) TestRequestStringUnixMicroArrayArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMicroArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33788,12 +37817,12 @@ func (c *Client) TestRequestStringUnixMicroArrayArray(ctx context.Context, reque return result, nil } -// TestRequestStringUnixMicroNullable invokes test_request_string_unix-micro_nullable operation. +// TestRequestStringUnixSeconds invokes test_request_string_unix-seconds operation. // -// POST /test_request_string_unix-micro_nullable -func (c *Client) TestRequestStringUnixMicroNullable(ctx context.Context, request OptNilStringUnixMicro) (res Error, err error) { +// POST /test_request_string_unix-seconds +func (c *Client) TestRequestStringUnixSeconds(ctx context.Context, request OptStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable"), + otelogen.OperationID("test_request_string_unix-seconds"), } // Validate request before sending. @@ -33808,7 +37837,7 @@ func (c *Client) TestRequestStringUnixMicroNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSeconds", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33825,14 +37854,14 @@ func (c *Client) TestRequestStringUnixMicroNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-micro_nullable" + u.Path += "/test_request_string_unix-seconds" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMicroNullableRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixSecondsRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33844,7 +37873,7 @@ func (c *Client) TestRequestStringUnixMicroNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMicroNullableResponse(resp, span) + result, err := decodeTestRequestStringUnixSecondsResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33852,12 +37881,12 @@ func (c *Client) TestRequestStringUnixMicroNullable(ctx context.Context, request return result, nil } -// TestRequestStringUnixMicroNullableArray invokes test_request_string_unix-micro_nullable_array operation. +// TestRequestStringUnixSecondsArray invokes test_request_string_unix-seconds_array operation. // -// POST /test_request_string_unix-micro_nullable_array -func (c *Client) TestRequestStringUnixMicroNullableArray(ctx context.Context, request []NilStringUnixMicro) (res Error, err error) { +// POST /test_request_string_unix-seconds_array +func (c *Client) TestRequestStringUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable_array"), + otelogen.OperationID("test_request_string_unix-seconds_array"), } // Validate request before sending. @@ -33872,7 +37901,7 @@ func (c *Client) TestRequestStringUnixMicroNullableArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33889,14 +37918,14 @@ func (c *Client) TestRequestStringUnixMicroNullableArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-micro_nullable_array" + u.Path += "/test_request_string_unix-seconds_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMicroNullableArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixSecondsArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33908,7 +37937,7 @@ func (c *Client) TestRequestStringUnixMicroNullableArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMicroNullableArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixSecondsArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -33916,12 +37945,12 @@ func (c *Client) TestRequestStringUnixMicroNullableArray(ctx context.Context, re return result, nil } -// TestRequestStringUnixMicroNullableArrayArray invokes test_request_string_unix-micro_nullable_array_array operation. +// TestRequestStringUnixSecondsArrayArray invokes test_request_string_unix-seconds_array_array operation. // -// POST /test_request_string_unix-micro_nullable_array_array -func (c *Client) TestRequestStringUnixMicroNullableArrayArray(ctx context.Context, request [][]NilStringUnixMicro) (res Error, err error) { +// POST /test_request_string_unix-seconds_array_array +func (c *Client) TestRequestStringUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-seconds_array_array"), } // Validate request before sending. if err := func() error { @@ -33958,7 +37987,7 @@ func (c *Client) TestRequestStringUnixMicroNullableArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMicroNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -33975,14 +38004,14 @@ func (c *Client) TestRequestStringUnixMicroNullableArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-micro_nullable_array_array" + u.Path += "/test_request_string_unix-seconds_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMicroNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixSecondsArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -33994,7 +38023,7 @@ func (c *Client) TestRequestStringUnixMicroNullableArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixSecondsArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34002,12 +38031,12 @@ func (c *Client) TestRequestStringUnixMicroNullableArrayArray(ctx context.Contex return result, nil } -// TestRequestStringUnixMilli invokes test_request_string_unix-milli operation. +// TestRequestStringUnixSecondsNullable invokes test_request_string_unix-seconds_nullable operation. // -// POST /test_request_string_unix-milli -func (c *Client) TestRequestStringUnixMilli(ctx context.Context, request OptStringUnixMilli) (res Error, err error) { +// POST /test_request_string_unix-seconds_nullable +func (c *Client) TestRequestStringUnixSecondsNullable(ctx context.Context, request OptNilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli"), + otelogen.OperationID("test_request_string_unix-seconds_nullable"), } // Validate request before sending. @@ -34022,7 +38051,7 @@ func (c *Client) TestRequestStringUnixMilli(ctx context.Context, request OptStri c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilli", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34039,14 +38068,14 @@ func (c *Client) TestRequestStringUnixMilli(ctx context.Context, request OptStri stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-milli" + u.Path += "/test_request_string_unix-seconds_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMilliRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixSecondsNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34058,7 +38087,7 @@ func (c *Client) TestRequestStringUnixMilli(ctx context.Context, request OptStri defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMilliResponse(resp, span) + result, err := decodeTestRequestStringUnixSecondsNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34066,12 +38095,12 @@ func (c *Client) TestRequestStringUnixMilli(ctx context.Context, request OptStri return result, nil } -// TestRequestStringUnixMilliArray invokes test_request_string_unix-milli_array operation. +// TestRequestStringUnixSecondsNullableArray invokes test_request_string_unix-seconds_nullable_array operation. // -// POST /test_request_string_unix-milli_array -func (c *Client) TestRequestStringUnixMilliArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_request_string_unix-seconds_nullable_array +func (c *Client) TestRequestStringUnixSecondsNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_array"), + otelogen.OperationID("test_request_string_unix-seconds_nullable_array"), } // Validate request before sending. @@ -34086,7 +38115,7 @@ func (c *Client) TestRequestStringUnixMilliArray(ctx context.Context, request [] c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34103,14 +38132,14 @@ func (c *Client) TestRequestStringUnixMilliArray(ctx context.Context, request [] stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-milli_array" + u.Path += "/test_request_string_unix-seconds_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMilliArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixSecondsNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34122,7 +38151,7 @@ func (c *Client) TestRequestStringUnixMilliArray(ctx context.Context, request [] defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMilliArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixSecondsNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34130,12 +38159,12 @@ func (c *Client) TestRequestStringUnixMilliArray(ctx context.Context, request [] return result, nil } -// TestRequestStringUnixMilliArrayArray invokes test_request_string_unix-milli_array_array operation. +// TestRequestStringUnixSecondsNullableArrayArray invokes test_request_string_unix-seconds_nullable_array_array operation. // -// POST /test_request_string_unix-milli_array_array -func (c *Client) TestRequestStringUnixMilliArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_request_string_unix-seconds_nullable_array_array +func (c *Client) TestRequestStringUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_array_array"), + otelogen.OperationID("test_request_string_unix-seconds_nullable_array_array"), } // Validate request before sending. if err := func() error { @@ -34172,7 +38201,7 @@ func (c *Client) TestRequestStringUnixMilliArrayArray(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34189,14 +38218,14 @@ func (c *Client) TestRequestStringUnixMilliArrayArray(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-milli_array_array" + u.Path += "/test_request_string_unix-seconds_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMilliArrayArrayRequest(request, r); err != nil { + if err := encodeTestRequestStringUnixSecondsNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34208,7 +38237,7 @@ func (c *Client) TestRequestStringUnixMilliArrayArray(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMilliArrayArrayResponse(resp, span) + result, err := decodeTestRequestStringUnixSecondsNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34216,12 +38245,12 @@ func (c *Client) TestRequestStringUnixMilliArrayArray(ctx context.Context, reque return result, nil } -// TestRequestStringUnixMilliNullable invokes test_request_string_unix-milli_nullable operation. +// TestResponseAny invokes test_response_Any operation. // -// POST /test_request_string_unix-milli_nullable -func (c *Client) TestRequestStringUnixMilliNullable(ctx context.Context, request OptNilStringUnixMilli) (res Error, err error) { +// POST /test_response_Any +func (c *Client) TestResponseAny(ctx context.Context, request string) (res jx.Raw, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable"), + otelogen.OperationID("test_response_Any"), } // Validate request before sending. @@ -34236,7 +38265,7 @@ func (c *Client) TestRequestStringUnixMilliNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseAny", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34253,14 +38282,14 @@ func (c *Client) TestRequestStringUnixMilliNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-milli_nullable" + u.Path += "/test_response_Any" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMilliNullableRequest(request, r); err != nil { + if err := encodeTestResponseAnyRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34272,7 +38301,7 @@ func (c *Client) TestRequestStringUnixMilliNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMilliNullableResponse(resp, span) + result, err := decodeTestResponseAnyResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34280,12 +38309,12 @@ func (c *Client) TestRequestStringUnixMilliNullable(ctx context.Context, request return result, nil } -// TestRequestStringUnixMilliNullableArray invokes test_request_string_unix-milli_nullable_array operation. +// TestResponseBoolean invokes test_response_boolean operation. // -// POST /test_request_string_unix-milli_nullable_array -func (c *Client) TestRequestStringUnixMilliNullableArray(ctx context.Context, request []NilStringUnixMilli) (res Error, err error) { +// POST /test_response_boolean +func (c *Client) TestResponseBoolean(ctx context.Context, request string) (res bool, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable_array"), + otelogen.OperationID("test_response_boolean"), } // Validate request before sending. @@ -34300,7 +38329,7 @@ func (c *Client) TestRequestStringUnixMilliNullableArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBoolean", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34317,14 +38346,14 @@ func (c *Client) TestRequestStringUnixMilliNullableArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-milli_nullable_array" + u.Path += "/test_response_boolean" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMilliNullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseBooleanRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34336,7 +38365,7 @@ func (c *Client) TestRequestStringUnixMilliNullableArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMilliNullableArrayResponse(resp, span) + result, err := decodeTestResponseBooleanResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34344,36 +38373,14 @@ func (c *Client) TestRequestStringUnixMilliNullableArray(ctx context.Context, re return result, nil } -// TestRequestStringUnixMilliNullableArrayArray invokes test_request_string_unix-milli_nullable_array_array operation. +// TestResponseBooleanArray invokes test_response_boolean_array operation. // -// POST /test_request_string_unix-milli_nullable_array_array -func (c *Client) TestRequestStringUnixMilliNullableArrayArray(ctx context.Context, request [][]NilStringUnixMilli) (res Error, err error) { +// POST /test_response_boolean_array +func (c *Client) TestResponseBooleanArray(ctx context.Context, request string) (res []bool, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable_array_array"), + otelogen.OperationID("test_response_boolean_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -34386,7 +38393,7 @@ func (c *Client) TestRequestStringUnixMilliNullableArrayArray(ctx context.Contex c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixMilliNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34403,14 +38410,14 @@ func (c *Client) TestRequestStringUnixMilliNullableArrayArray(ctx context.Contex stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-milli_nullable_array_array" + u.Path += "/test_response_boolean_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixMilliNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseBooleanArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34422,7 +38429,7 @@ func (c *Client) TestRequestStringUnixMilliNullableArrayArray(ctx context.Contex defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseBooleanArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34430,12 +38437,12 @@ func (c *Client) TestRequestStringUnixMilliNullableArrayArray(ctx context.Contex return result, nil } -// TestRequestStringUnixNano invokes test_request_string_unix-nano operation. +// TestResponseBooleanArrayArray invokes test_response_boolean_array_array operation. // -// POST /test_request_string_unix-nano -func (c *Client) TestRequestStringUnixNano(ctx context.Context, request OptStringUnixNano) (res Error, err error) { +// POST /test_response_boolean_array_array +func (c *Client) TestResponseBooleanArrayArray(ctx context.Context, request string) (res [][]bool, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano"), + otelogen.OperationID("test_response_boolean_array_array"), } // Validate request before sending. @@ -34450,7 +38457,7 @@ func (c *Client) TestRequestStringUnixNano(ctx context.Context, request OptStrin c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNano", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34467,14 +38474,14 @@ func (c *Client) TestRequestStringUnixNano(ctx context.Context, request OptStrin stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-nano" + u.Path += "/test_response_boolean_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNanoRequest(request, r); err != nil { + if err := encodeTestResponseBooleanArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34486,7 +38493,7 @@ func (c *Client) TestRequestStringUnixNano(ctx context.Context, request OptStrin defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNanoResponse(resp, span) + result, err := decodeTestResponseBooleanArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34494,12 +38501,12 @@ func (c *Client) TestRequestStringUnixNano(ctx context.Context, request OptStrin return result, nil } -// TestRequestStringUnixNanoArray invokes test_request_string_unix-nano_array operation. +// TestResponseBooleanNullable invokes test_response_boolean_nullable operation. // -// POST /test_request_string_unix-nano_array -func (c *Client) TestRequestStringUnixNanoArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_response_boolean_nullable +func (c *Client) TestResponseBooleanNullable(ctx context.Context, request string) (res NilBool, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_array"), + otelogen.OperationID("test_response_boolean_nullable"), } // Validate request before sending. @@ -34514,7 +38521,7 @@ func (c *Client) TestRequestStringUnixNanoArray(ctx context.Context, request []t c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34531,14 +38538,14 @@ func (c *Client) TestRequestStringUnixNanoArray(ctx context.Context, request []t stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-nano_array" + u.Path += "/test_response_boolean_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNanoArrayRequest(request, r); err != nil { + if err := encodeTestResponseBooleanNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34550,7 +38557,7 @@ func (c *Client) TestRequestStringUnixNanoArray(ctx context.Context, request []t defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNanoArrayResponse(resp, span) + result, err := decodeTestResponseBooleanNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34558,36 +38565,14 @@ func (c *Client) TestRequestStringUnixNanoArray(ctx context.Context, request []t return result, nil } -// TestRequestStringUnixNanoArrayArray invokes test_request_string_unix-nano_array_array operation. +// TestResponseBooleanNullableArray invokes test_response_boolean_nullable_array operation. // -// POST /test_request_string_unix-nano_array_array -func (c *Client) TestRequestStringUnixNanoArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_response_boolean_nullable_array +func (c *Client) TestResponseBooleanNullableArray(ctx context.Context, request string) (res []NilBool, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_array_array"), + otelogen.OperationID("test_response_boolean_nullable_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -34600,7 +38585,7 @@ func (c *Client) TestRequestStringUnixNanoArrayArray(ctx context.Context, reques c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34617,14 +38602,14 @@ func (c *Client) TestRequestStringUnixNanoArrayArray(ctx context.Context, reques stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-nano_array_array" + u.Path += "/test_response_boolean_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNanoArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseBooleanNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34636,7 +38621,7 @@ func (c *Client) TestRequestStringUnixNanoArrayArray(ctx context.Context, reques defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNanoArrayArrayResponse(resp, span) + result, err := decodeTestResponseBooleanNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34644,12 +38629,12 @@ func (c *Client) TestRequestStringUnixNanoArrayArray(ctx context.Context, reques return result, nil } -// TestRequestStringUnixNanoNullable invokes test_request_string_unix-nano_nullable operation. +// TestResponseBooleanNullableArrayArray invokes test_response_boolean_nullable_array_array operation. // -// POST /test_request_string_unix-nano_nullable -func (c *Client) TestRequestStringUnixNanoNullable(ctx context.Context, request OptNilStringUnixNano) (res Error, err error) { +// POST /test_response_boolean_nullable_array_array +func (c *Client) TestResponseBooleanNullableArrayArray(ctx context.Context, request string) (res [][]NilBool, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable"), + otelogen.OperationID("test_response_boolean_nullable_array_array"), } // Validate request before sending. @@ -34664,7 +38649,7 @@ func (c *Client) TestRequestStringUnixNanoNullable(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34681,14 +38666,14 @@ func (c *Client) TestRequestStringUnixNanoNullable(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-nano_nullable" + u.Path += "/test_response_boolean_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNanoNullableRequest(request, r); err != nil { + if err := encodeTestResponseBooleanNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34700,7 +38685,7 @@ func (c *Client) TestRequestStringUnixNanoNullable(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNanoNullableResponse(resp, span) + result, err := decodeTestResponseBooleanNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34708,12 +38693,12 @@ func (c *Client) TestRequestStringUnixNanoNullable(ctx context.Context, request return result, nil } -// TestRequestStringUnixNanoNullableArray invokes test_request_string_unix-nano_nullable_array operation. +// TestResponseEmptyStruct invokes test_response_EmptyStruct operation. // -// POST /test_request_string_unix-nano_nullable_array -func (c *Client) TestRequestStringUnixNanoNullableArray(ctx context.Context, request []NilStringUnixNano) (res Error, err error) { +// POST /test_response_EmptyStruct +func (c *Client) TestResponseEmptyStruct(ctx context.Context, request string) (res TestResponseEmptyStructOK, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable_array"), + otelogen.OperationID("test_response_EmptyStruct"), } // Validate request before sending. @@ -34728,7 +38713,7 @@ func (c *Client) TestRequestStringUnixNanoNullableArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseEmptyStruct", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34745,14 +38730,14 @@ func (c *Client) TestRequestStringUnixNanoNullableArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-nano_nullable_array" + u.Path += "/test_response_EmptyStruct" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNanoNullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseEmptyStructRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34764,7 +38749,7 @@ func (c *Client) TestRequestStringUnixNanoNullableArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNanoNullableArrayResponse(resp, span) + result, err := decodeTestResponseEmptyStructResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34772,36 +38757,14 @@ func (c *Client) TestRequestStringUnixNanoNullableArray(ctx context.Context, req return result, nil } -// TestRequestStringUnixNanoNullableArrayArray invokes test_request_string_unix-nano_nullable_array_array operation. -// -// POST /test_request_string_unix-nano_nullable_array_array -func (c *Client) TestRequestStringUnixNanoNullableArrayArray(ctx context.Context, request [][]NilStringUnixNano) (res Error, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable_array_array"), - } - // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") +// TestResponseFormatTest invokes test_response_FormatTest operation. +// +// POST /test_response_FormatTest +func (c *Client) TestResponseFormatTest(ctx context.Context, request string) (res TestResponseFormatTestOK, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_FormatTest"), } + // Validate request before sending. // Run stopwatch. startTime := time.Now() @@ -34814,7 +38777,7 @@ func (c *Client) TestRequestStringUnixNanoNullableArrayArray(ctx context.Context c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNanoNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseFormatTest", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34831,14 +38794,14 @@ func (c *Client) TestRequestStringUnixNanoNullableArrayArray(ctx context.Context stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-nano_nullable_array_array" + u.Path += "/test_response_FormatTest" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNanoNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseFormatTestRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34850,7 +38813,7 @@ func (c *Client) TestRequestStringUnixNanoNullableArrayArray(ctx context.Context defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseFormatTestResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34858,12 +38821,12 @@ func (c *Client) TestRequestStringUnixNanoNullableArrayArray(ctx context.Context return result, nil } -// TestRequestStringUnixNullable invokes test_request_string_unix_nullable operation. +// TestResponseInteger invokes test_response_integer operation. // -// POST /test_request_string_unix_nullable -func (c *Client) TestRequestStringUnixNullable(ctx context.Context, request OptNilStringUnixSeconds) (res Error, err error) { +// POST /test_response_integer +func (c *Client) TestResponseInteger(ctx context.Context, request string) (res int, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable"), + otelogen.OperationID("test_response_integer"), } // Validate request before sending. @@ -34878,7 +38841,7 @@ func (c *Client) TestRequestStringUnixNullable(ctx context.Context, request OptN c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseInteger", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34895,14 +38858,14 @@ func (c *Client) TestRequestStringUnixNullable(ctx context.Context, request OptN stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix_nullable" + u.Path += "/test_response_integer" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNullableRequest(request, r); err != nil { + if err := encodeTestResponseIntegerRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34914,7 +38877,7 @@ func (c *Client) TestRequestStringUnixNullable(ctx context.Context, request OptN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNullableResponse(resp, span) + result, err := decodeTestResponseIntegerResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34922,12 +38885,12 @@ func (c *Client) TestRequestStringUnixNullable(ctx context.Context, request OptN return result, nil } -// TestRequestStringUnixNullableArray invokes test_request_string_unix_nullable_array operation. +// TestResponseIntegerArray invokes test_response_integer_array operation. // -// POST /test_request_string_unix_nullable_array -func (c *Client) TestRequestStringUnixNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { +// POST /test_response_integer_array +func (c *Client) TestResponseIntegerArray(ctx context.Context, request string) (res []int, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable_array"), + otelogen.OperationID("test_response_integer_array"), } // Validate request before sending. @@ -34942,7 +38905,7 @@ func (c *Client) TestRequestStringUnixNullableArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -34959,14 +38922,14 @@ func (c *Client) TestRequestStringUnixNullableArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix_nullable_array" + u.Path += "/test_response_integer_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -34978,7 +38941,7 @@ func (c *Client) TestRequestStringUnixNullableArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNullableArrayResponse(resp, span) + result, err := decodeTestResponseIntegerArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -34986,36 +38949,14 @@ func (c *Client) TestRequestStringUnixNullableArray(ctx context.Context, request return result, nil } -// TestRequestStringUnixNullableArrayArray invokes test_request_string_unix_nullable_array_array operation. +// TestResponseIntegerArrayArray invokes test_response_integer_array_array operation. // -// POST /test_request_string_unix_nullable_array_array -func (c *Client) TestRequestStringUnixNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { +// POST /test_response_integer_array_array +func (c *Client) TestResponseIntegerArrayArray(ctx context.Context, request string) (res [][]int, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable_array_array"), + otelogen.OperationID("test_response_integer_array_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -35028,7 +38969,7 @@ func (c *Client) TestRequestStringUnixNullableArrayArray(ctx context.Context, re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35045,14 +38986,14 @@ func (c *Client) TestRequestStringUnixNullableArrayArray(ctx context.Context, re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix_nullable_array_array" + u.Path += "/test_response_integer_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35064,7 +39005,7 @@ func (c *Client) TestRequestStringUnixNullableArrayArray(ctx context.Context, re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixNullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35072,12 +39013,12 @@ func (c *Client) TestRequestStringUnixNullableArrayArray(ctx context.Context, re return result, nil } -// TestRequestStringUnixSeconds invokes test_request_string_unix-seconds operation. +// TestResponseIntegerInt32 invokes test_response_integer_int32 operation. // -// POST /test_request_string_unix-seconds -func (c *Client) TestRequestStringUnixSeconds(ctx context.Context, request OptStringUnixSeconds) (res Error, err error) { +// POST /test_response_integer_int32 +func (c *Client) TestResponseIntegerInt32(ctx context.Context, request string) (res int32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds"), + otelogen.OperationID("test_response_integer_int32"), } // Validate request before sending. @@ -35092,7 +39033,7 @@ func (c *Client) TestRequestStringUnixSeconds(ctx context.Context, request OptSt c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSeconds", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35109,14 +39050,14 @@ func (c *Client) TestRequestStringUnixSeconds(ctx context.Context, request OptSt stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-seconds" + u.Path += "/test_response_integer_int32" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixSecondsRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt32Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35128,7 +39069,7 @@ func (c *Client) TestRequestStringUnixSeconds(ctx context.Context, request OptSt defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixSecondsResponse(resp, span) + result, err := decodeTestResponseIntegerInt32Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35136,12 +39077,12 @@ func (c *Client) TestRequestStringUnixSeconds(ctx context.Context, request OptSt return result, nil } -// TestRequestStringUnixSecondsArray invokes test_request_string_unix-seconds_array operation. +// TestResponseIntegerInt32Array invokes test_response_integer_int32_array operation. // -// POST /test_request_string_unix-seconds_array -func (c *Client) TestRequestStringUnixSecondsArray(ctx context.Context, request []time.Time) (res Error, err error) { +// POST /test_response_integer_int32_array +func (c *Client) TestResponseIntegerInt32Array(ctx context.Context, request string) (res []int32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_array"), + otelogen.OperationID("test_response_integer_int32_array"), } // Validate request before sending. @@ -35156,7 +39097,7 @@ func (c *Client) TestRequestStringUnixSecondsArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35173,14 +39114,14 @@ func (c *Client) TestRequestStringUnixSecondsArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-seconds_array" + u.Path += "/test_response_integer_int32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixSecondsArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35192,7 +39133,7 @@ func (c *Client) TestRequestStringUnixSecondsArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixSecondsArrayResponse(resp, span) + result, err := decodeTestResponseIntegerInt32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35200,36 +39141,14 @@ func (c *Client) TestRequestStringUnixSecondsArray(ctx context.Context, request return result, nil } -// TestRequestStringUnixSecondsArrayArray invokes test_request_string_unix-seconds_array_array operation. +// TestResponseIntegerInt32ArrayArray invokes test_response_integer_int32_array_array operation. // -// POST /test_request_string_unix-seconds_array_array -func (c *Client) TestRequestStringUnixSecondsArrayArray(ctx context.Context, request [][]time.Time) (res Error, err error) { +// POST /test_response_integer_int32_array_array +func (c *Client) TestResponseIntegerInt32ArrayArray(ctx context.Context, request string) (res [][]int32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_array_array"), + otelogen.OperationID("test_response_integer_int32_array_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -35242,7 +39161,7 @@ func (c *Client) TestRequestStringUnixSecondsArrayArray(ctx context.Context, req c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35259,14 +39178,14 @@ func (c *Client) TestRequestStringUnixSecondsArrayArray(ctx context.Context, req stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-seconds_array_array" + u.Path += "/test_response_integer_int32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixSecondsArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35278,7 +39197,7 @@ func (c *Client) TestRequestStringUnixSecondsArrayArray(ctx context.Context, req defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixSecondsArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerInt32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35286,12 +39205,12 @@ func (c *Client) TestRequestStringUnixSecondsArrayArray(ctx context.Context, req return result, nil } -// TestRequestStringUnixSecondsNullable invokes test_request_string_unix-seconds_nullable operation. +// TestResponseIntegerInt32Nullable invokes test_response_integer_int32_nullable operation. // -// POST /test_request_string_unix-seconds_nullable -func (c *Client) TestRequestStringUnixSecondsNullable(ctx context.Context, request OptNilStringUnixSeconds) (res Error, err error) { +// POST /test_response_integer_int32_nullable +func (c *Client) TestResponseIntegerInt32Nullable(ctx context.Context, request string) (res NilInt32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable"), + otelogen.OperationID("test_response_integer_int32_nullable"), } // Validate request before sending. @@ -35306,7 +39225,7 @@ func (c *Client) TestRequestStringUnixSecondsNullable(ctx context.Context, reque c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35323,14 +39242,14 @@ func (c *Client) TestRequestStringUnixSecondsNullable(ctx context.Context, reque stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-seconds_nullable" + u.Path += "/test_response_integer_int32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixSecondsNullableRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35342,7 +39261,7 @@ func (c *Client) TestRequestStringUnixSecondsNullable(ctx context.Context, reque defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixSecondsNullableResponse(resp, span) + result, err := decodeTestResponseIntegerInt32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35350,12 +39269,12 @@ func (c *Client) TestRequestStringUnixSecondsNullable(ctx context.Context, reque return result, nil } -// TestRequestStringUnixSecondsNullableArray invokes test_request_string_unix-seconds_nullable_array operation. +// TestResponseIntegerInt32NullableArray invokes test_response_integer_int32_nullable_array operation. // -// POST /test_request_string_unix-seconds_nullable_array -func (c *Client) TestRequestStringUnixSecondsNullableArray(ctx context.Context, request []NilStringUnixSeconds) (res Error, err error) { +// POST /test_response_integer_int32_nullable_array +func (c *Client) TestResponseIntegerInt32NullableArray(ctx context.Context, request string) (res []NilInt32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable_array"), + otelogen.OperationID("test_response_integer_int32_nullable_array"), } // Validate request before sending. @@ -35370,7 +39289,7 @@ func (c *Client) TestRequestStringUnixSecondsNullableArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35387,14 +39306,14 @@ func (c *Client) TestRequestStringUnixSecondsNullableArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-seconds_nullable_array" + u.Path += "/test_response_integer_int32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixSecondsNullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35406,7 +39325,7 @@ func (c *Client) TestRequestStringUnixSecondsNullableArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixSecondsNullableArrayResponse(resp, span) + result, err := decodeTestResponseIntegerInt32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35414,36 +39333,14 @@ func (c *Client) TestRequestStringUnixSecondsNullableArray(ctx context.Context, return result, nil } -// TestRequestStringUnixSecondsNullableArrayArray invokes test_request_string_unix-seconds_nullable_array_array operation. +// TestResponseIntegerInt32NullableArrayArray invokes test_response_integer_int32_nullable_array_array operation. // -// POST /test_request_string_unix-seconds_nullable_array_array -func (c *Client) TestRequestStringUnixSecondsNullableArrayArray(ctx context.Context, request [][]NilStringUnixSeconds) (res Error, err error) { +// POST /test_response_integer_int32_nullable_array_array +func (c *Client) TestResponseIntegerInt32NullableArrayArray(ctx context.Context, request string) (res [][]NilInt32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_response_integer_int32_nullable_array_array"), } // Validate request before sending. - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return res, errors.Wrap(err, "validate") - } // Run stopwatch. startTime := time.Now() @@ -35456,7 +39353,7 @@ func (c *Client) TestRequestStringUnixSecondsNullableArrayArray(ctx context.Cont c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringUnixSecondsNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35473,14 +39370,14 @@ func (c *Client) TestRequestStringUnixSecondsNullableArrayArray(ctx context.Cont stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_request_string_unix-seconds_nullable_array_array" + u.Path += "/test_response_integer_int32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestRequestStringUnixSecondsNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35492,7 +39389,7 @@ func (c *Client) TestRequestStringUnixSecondsNullableArrayArray(ctx context.Cont defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestRequestStringUnixSecondsNullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerInt32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35500,12 +39397,12 @@ func (c *Client) TestRequestStringUnixSecondsNullableArrayArray(ctx context.Cont return result, nil } -// TestResponseAny invokes test_response_Any operation. +// TestResponseIntegerInt64 invokes test_response_integer_int64 operation. // -// POST /test_response_Any -func (c *Client) TestResponseAny(ctx context.Context, request string) (res jx.Raw, err error) { +// POST /test_response_integer_int64 +func (c *Client) TestResponseIntegerInt64(ctx context.Context, request string) (res int64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_Any"), + otelogen.OperationID("test_response_integer_int64"), } // Validate request before sending. @@ -35520,7 +39417,7 @@ func (c *Client) TestResponseAny(ctx context.Context, request string) (res jx.Ra c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseAny", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35537,14 +39434,14 @@ func (c *Client) TestResponseAny(ctx context.Context, request string) (res jx.Ra stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_Any" + u.Path += "/test_response_integer_int64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseAnyRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35556,7 +39453,7 @@ func (c *Client) TestResponseAny(ctx context.Context, request string) (res jx.Ra defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseAnyResponse(resp, span) + result, err := decodeTestResponseIntegerInt64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35564,12 +39461,12 @@ func (c *Client) TestResponseAny(ctx context.Context, request string) (res jx.Ra return result, nil } -// TestResponseBoolean invokes test_response_boolean operation. +// TestResponseIntegerInt64Array invokes test_response_integer_int64_array operation. // -// POST /test_response_boolean -func (c *Client) TestResponseBoolean(ctx context.Context, request string) (res bool, err error) { +// POST /test_response_integer_int64_array +func (c *Client) TestResponseIntegerInt64Array(ctx context.Context, request string) (res []int64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean"), + otelogen.OperationID("test_response_integer_int64_array"), } // Validate request before sending. @@ -35584,7 +39481,7 @@ func (c *Client) TestResponseBoolean(ctx context.Context, request string) (res b c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBoolean", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35601,14 +39498,14 @@ func (c *Client) TestResponseBoolean(ctx context.Context, request string) (res b stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_boolean" + u.Path += "/test_response_integer_int64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseBooleanRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35620,7 +39517,7 @@ func (c *Client) TestResponseBoolean(ctx context.Context, request string) (res b defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseBooleanResponse(resp, span) + result, err := decodeTestResponseIntegerInt64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35628,12 +39525,12 @@ func (c *Client) TestResponseBoolean(ctx context.Context, request string) (res b return result, nil } -// TestResponseBooleanArray invokes test_response_boolean_array operation. +// TestResponseIntegerInt64ArrayArray invokes test_response_integer_int64_array_array operation. // -// POST /test_response_boolean_array -func (c *Client) TestResponseBooleanArray(ctx context.Context, request string) (res []bool, err error) { +// POST /test_response_integer_int64_array_array +func (c *Client) TestResponseIntegerInt64ArrayArray(ctx context.Context, request string) (res [][]int64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_array"), + otelogen.OperationID("test_response_integer_int64_array_array"), } // Validate request before sending. @@ -35648,7 +39545,7 @@ func (c *Client) TestResponseBooleanArray(ctx context.Context, request string) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35665,14 +39562,14 @@ func (c *Client) TestResponseBooleanArray(ctx context.Context, request string) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_boolean_array" + u.Path += "/test_response_integer_int64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseBooleanArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35684,7 +39581,7 @@ func (c *Client) TestResponseBooleanArray(ctx context.Context, request string) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseBooleanArrayResponse(resp, span) + result, err := decodeTestResponseIntegerInt64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35692,12 +39589,12 @@ func (c *Client) TestResponseBooleanArray(ctx context.Context, request string) ( return result, nil } -// TestResponseBooleanArrayArray invokes test_response_boolean_array_array operation. +// TestResponseIntegerInt64Nullable invokes test_response_integer_int64_nullable operation. // -// POST /test_response_boolean_array_array -func (c *Client) TestResponseBooleanArrayArray(ctx context.Context, request string) (res [][]bool, err error) { +// POST /test_response_integer_int64_nullable +func (c *Client) TestResponseIntegerInt64Nullable(ctx context.Context, request string) (res NilInt64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_array_array"), + otelogen.OperationID("test_response_integer_int64_nullable"), } // Validate request before sending. @@ -35712,7 +39609,7 @@ func (c *Client) TestResponseBooleanArrayArray(ctx context.Context, request stri c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35729,14 +39626,14 @@ func (c *Client) TestResponseBooleanArrayArray(ctx context.Context, request stri stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_boolean_array_array" + u.Path += "/test_response_integer_int64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseBooleanArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35748,7 +39645,7 @@ func (c *Client) TestResponseBooleanArrayArray(ctx context.Context, request stri defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseBooleanArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerInt64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35756,12 +39653,12 @@ func (c *Client) TestResponseBooleanArrayArray(ctx context.Context, request stri return result, nil } -// TestResponseBooleanNullable invokes test_response_boolean_nullable operation. +// TestResponseIntegerInt64NullableArray invokes test_response_integer_int64_nullable_array operation. // -// POST /test_response_boolean_nullable -func (c *Client) TestResponseBooleanNullable(ctx context.Context, request string) (res NilBool, err error) { +// POST /test_response_integer_int64_nullable_array +func (c *Client) TestResponseIntegerInt64NullableArray(ctx context.Context, request string) (res []NilInt64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable"), + otelogen.OperationID("test_response_integer_int64_nullable_array"), } // Validate request before sending. @@ -35776,7 +39673,7 @@ func (c *Client) TestResponseBooleanNullable(ctx context.Context, request string c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35793,14 +39690,14 @@ func (c *Client) TestResponseBooleanNullable(ctx context.Context, request string stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_boolean_nullable" + u.Path += "/test_response_integer_int64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseBooleanNullableRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35812,7 +39709,7 @@ func (c *Client) TestResponseBooleanNullable(ctx context.Context, request string defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseBooleanNullableResponse(resp, span) + result, err := decodeTestResponseIntegerInt64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35820,12 +39717,12 @@ func (c *Client) TestResponseBooleanNullable(ctx context.Context, request string return result, nil } -// TestResponseBooleanNullableArray invokes test_response_boolean_nullable_array operation. +// TestResponseIntegerInt64NullableArrayArray invokes test_response_integer_int64_nullable_array_array operation. // -// POST /test_response_boolean_nullable_array -func (c *Client) TestResponseBooleanNullableArray(ctx context.Context, request string) (res []NilBool, err error) { +// POST /test_response_integer_int64_nullable_array_array +func (c *Client) TestResponseIntegerInt64NullableArrayArray(ctx context.Context, request string) (res [][]NilInt64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable_array"), + otelogen.OperationID("test_response_integer_int64_nullable_array_array"), } // Validate request before sending. @@ -35840,7 +39737,7 @@ func (c *Client) TestResponseBooleanNullableArray(ctx context.Context, request s c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35857,14 +39754,14 @@ func (c *Client) TestResponseBooleanNullableArray(ctx context.Context, request s stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_boolean_nullable_array" + u.Path += "/test_response_integer_int64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseBooleanNullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerInt64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35876,7 +39773,7 @@ func (c *Client) TestResponseBooleanNullableArray(ctx context.Context, request s defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseBooleanNullableArrayResponse(resp, span) + result, err := decodeTestResponseIntegerInt64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35884,12 +39781,12 @@ func (c *Client) TestResponseBooleanNullableArray(ctx context.Context, request s return result, nil } -// TestResponseBooleanNullableArrayArray invokes test_response_boolean_nullable_array_array operation. +// TestResponseIntegerNullable invokes test_response_integer_nullable operation. // -// POST /test_response_boolean_nullable_array_array -func (c *Client) TestResponseBooleanNullableArrayArray(ctx context.Context, request string) (res [][]NilBool, err error) { +// POST /test_response_integer_nullable +func (c *Client) TestResponseIntegerNullable(ctx context.Context, request string) (res NilInt, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable_array_array"), + otelogen.OperationID("test_response_integer_nullable"), } // Validate request before sending. @@ -35904,7 +39801,7 @@ func (c *Client) TestResponseBooleanNullableArrayArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseBooleanNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35921,14 +39818,14 @@ func (c *Client) TestResponseBooleanNullableArrayArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_boolean_nullable_array_array" + u.Path += "/test_response_integer_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseBooleanNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -35940,7 +39837,7 @@ func (c *Client) TestResponseBooleanNullableArrayArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseBooleanNullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -35948,12 +39845,12 @@ func (c *Client) TestResponseBooleanNullableArrayArray(ctx context.Context, requ return result, nil } -// TestResponseEmptyStruct invokes test_response_EmptyStruct operation. +// TestResponseIntegerNullableArray invokes test_response_integer_nullable_array operation. // -// POST /test_response_EmptyStruct -func (c *Client) TestResponseEmptyStruct(ctx context.Context, request string) (res TestResponseEmptyStructOK, err error) { +// POST /test_response_integer_nullable_array +func (c *Client) TestResponseIntegerNullableArray(ctx context.Context, request string) (res []NilInt, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_EmptyStruct"), + otelogen.OperationID("test_response_integer_nullable_array"), } // Validate request before sending. @@ -35968,7 +39865,7 @@ func (c *Client) TestResponseEmptyStruct(ctx context.Context, request string) (r c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseEmptyStruct", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -35985,14 +39882,14 @@ func (c *Client) TestResponseEmptyStruct(ctx context.Context, request string) (r stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_EmptyStruct" + u.Path += "/test_response_integer_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseEmptyStructRequest(request, r); err != nil { + if err := encodeTestResponseIntegerNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36004,7 +39901,7 @@ func (c *Client) TestResponseEmptyStruct(ctx context.Context, request string) (r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseEmptyStructResponse(resp, span) + result, err := decodeTestResponseIntegerNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36012,12 +39909,12 @@ func (c *Client) TestResponseEmptyStruct(ctx context.Context, request string) (r return result, nil } -// TestResponseFormatTest invokes test_response_FormatTest operation. +// TestResponseIntegerNullableArrayArray invokes test_response_integer_nullable_array_array operation. // -// POST /test_response_FormatTest -func (c *Client) TestResponseFormatTest(ctx context.Context, request string) (res TestResponseFormatTestOK, err error) { +// POST /test_response_integer_nullable_array_array +func (c *Client) TestResponseIntegerNullableArrayArray(ctx context.Context, request string) (res [][]NilInt, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_FormatTest"), + otelogen.OperationID("test_response_integer_nullable_array_array"), } // Validate request before sending. @@ -36032,7 +39929,7 @@ func (c *Client) TestResponseFormatTest(ctx context.Context, request string) (re c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseFormatTest", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36049,14 +39946,14 @@ func (c *Client) TestResponseFormatTest(ctx context.Context, request string) (re stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_FormatTest" + u.Path += "/test_response_integer_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseFormatTestRequest(request, r); err != nil { + if err := encodeTestResponseIntegerNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36068,7 +39965,7 @@ func (c *Client) TestResponseFormatTest(ctx context.Context, request string) (re defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseFormatTestResponse(resp, span) + result, err := decodeTestResponseIntegerNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36076,12 +39973,12 @@ func (c *Client) TestResponseFormatTest(ctx context.Context, request string) (re return result, nil } -// TestResponseInteger invokes test_response_integer operation. +// TestResponseIntegerUint invokes test_response_integer_uint operation. // -// POST /test_response_integer -func (c *Client) TestResponseInteger(ctx context.Context, request string) (res int, err error) { +// POST /test_response_integer_uint +func (c *Client) TestResponseIntegerUint(ctx context.Context, request string) (res uint, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer"), + otelogen.OperationID("test_response_integer_uint"), } // Validate request before sending. @@ -36096,7 +39993,7 @@ func (c *Client) TestResponseInteger(ctx context.Context, request string) (res i c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseInteger", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36113,14 +40010,14 @@ func (c *Client) TestResponseInteger(ctx context.Context, request string) (res i stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer" + u.Path += "/test_response_integer_uint" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUintRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36132,7 +40029,7 @@ func (c *Client) TestResponseInteger(ctx context.Context, request string) (res i defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerResponse(resp, span) + result, err := decodeTestResponseIntegerUintResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36140,12 +40037,12 @@ func (c *Client) TestResponseInteger(ctx context.Context, request string) (res i return result, nil } -// TestResponseIntegerArray invokes test_response_integer_array operation. +// TestResponseIntegerUint32 invokes test_response_integer_uint32 operation. // -// POST /test_response_integer_array -func (c *Client) TestResponseIntegerArray(ctx context.Context, request string) (res []int, err error) { +// POST /test_response_integer_uint32 +func (c *Client) TestResponseIntegerUint32(ctx context.Context, request string) (res uint32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_array"), + otelogen.OperationID("test_response_integer_uint32"), } // Validate request before sending. @@ -36160,7 +40057,7 @@ func (c *Client) TestResponseIntegerArray(ctx context.Context, request string) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36177,14 +40074,14 @@ func (c *Client) TestResponseIntegerArray(ctx context.Context, request string) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_array" + u.Path += "/test_response_integer_uint32" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint32Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36196,7 +40093,7 @@ func (c *Client) TestResponseIntegerArray(ctx context.Context, request string) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint32Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36204,12 +40101,12 @@ func (c *Client) TestResponseIntegerArray(ctx context.Context, request string) ( return result, nil } -// TestResponseIntegerArrayArray invokes test_response_integer_array_array operation. +// TestResponseIntegerUint32Array invokes test_response_integer_uint32_array operation. // -// POST /test_response_integer_array_array -func (c *Client) TestResponseIntegerArrayArray(ctx context.Context, request string) (res [][]int, err error) { +// POST /test_response_integer_uint32_array +func (c *Client) TestResponseIntegerUint32Array(ctx context.Context, request string) (res []uint32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_array_array"), + otelogen.OperationID("test_response_integer_uint32_array"), } // Validate request before sending. @@ -36224,7 +40121,7 @@ func (c *Client) TestResponseIntegerArrayArray(ctx context.Context, request stri c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36241,14 +40138,14 @@ func (c *Client) TestResponseIntegerArrayArray(ctx context.Context, request stri stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_array_array" + u.Path += "/test_response_integer_uint32_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint32ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36260,7 +40157,7 @@ func (c *Client) TestResponseIntegerArrayArray(ctx context.Context, request stri defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint32ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36268,12 +40165,12 @@ func (c *Client) TestResponseIntegerArrayArray(ctx context.Context, request stri return result, nil } -// TestResponseIntegerInt32 invokes test_response_integer_int32 operation. +// TestResponseIntegerUint32ArrayArray invokes test_response_integer_uint32_array_array operation. // -// POST /test_response_integer_int32 -func (c *Client) TestResponseIntegerInt32(ctx context.Context, request string) (res int32, err error) { +// POST /test_response_integer_uint32_array_array +func (c *Client) TestResponseIntegerUint32ArrayArray(ctx context.Context, request string) (res [][]uint32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32"), + otelogen.OperationID("test_response_integer_uint32_array_array"), } // Validate request before sending. @@ -36288,7 +40185,7 @@ func (c *Client) TestResponseIntegerInt32(ctx context.Context, request string) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36305,14 +40202,14 @@ func (c *Client) TestResponseIntegerInt32(ctx context.Context, request string) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int32" + u.Path += "/test_response_integer_uint32_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt32Request(request, r); err != nil { + if err := encodeTestResponseIntegerUint32ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36324,7 +40221,7 @@ func (c *Client) TestResponseIntegerInt32(ctx context.Context, request string) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt32Response(resp, span) + result, err := decodeTestResponseIntegerUint32ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36332,12 +40229,12 @@ func (c *Client) TestResponseIntegerInt32(ctx context.Context, request string) ( return result, nil } -// TestResponseIntegerInt32Array invokes test_response_integer_int32_array operation. +// TestResponseIntegerUint32Nullable invokes test_response_integer_uint32_nullable operation. // -// POST /test_response_integer_int32_array -func (c *Client) TestResponseIntegerInt32Array(ctx context.Context, request string) (res []int32, err error) { +// POST /test_response_integer_uint32_nullable +func (c *Client) TestResponseIntegerUint32Nullable(ctx context.Context, request string) (res NilUint32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_array"), + otelogen.OperationID("test_response_integer_uint32_nullable"), } // Validate request before sending. @@ -36352,7 +40249,7 @@ func (c *Client) TestResponseIntegerInt32Array(ctx context.Context, request stri c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36369,14 +40266,14 @@ func (c *Client) TestResponseIntegerInt32Array(ctx context.Context, request stri stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int32_array" + u.Path += "/test_response_integer_uint32_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt32ArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint32NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36388,7 +40285,7 @@ func (c *Client) TestResponseIntegerInt32Array(ctx context.Context, request stri defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt32ArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint32NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36396,12 +40293,12 @@ func (c *Client) TestResponseIntegerInt32Array(ctx context.Context, request stri return result, nil } -// TestResponseIntegerInt32ArrayArray invokes test_response_integer_int32_array_array operation. +// TestResponseIntegerUint32NullableArray invokes test_response_integer_uint32_nullable_array operation. // -// POST /test_response_integer_int32_array_array -func (c *Client) TestResponseIntegerInt32ArrayArray(ctx context.Context, request string) (res [][]int32, err error) { +// POST /test_response_integer_uint32_nullable_array +func (c *Client) TestResponseIntegerUint32NullableArray(ctx context.Context, request string) (res []NilUint32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_array_array"), + otelogen.OperationID("test_response_integer_uint32_nullable_array"), } // Validate request before sending. @@ -36416,7 +40313,7 @@ func (c *Client) TestResponseIntegerInt32ArrayArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36433,14 +40330,14 @@ func (c *Client) TestResponseIntegerInt32ArrayArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int32_array_array" + u.Path += "/test_response_integer_uint32_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt32ArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint32NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36452,7 +40349,7 @@ func (c *Client) TestResponseIntegerInt32ArrayArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt32ArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint32NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36460,12 +40357,12 @@ func (c *Client) TestResponseIntegerInt32ArrayArray(ctx context.Context, request return result, nil } -// TestResponseIntegerInt32Nullable invokes test_response_integer_int32_nullable operation. +// TestResponseIntegerUint32NullableArrayArray invokes test_response_integer_uint32_nullable_array_array operation. // -// POST /test_response_integer_int32_nullable -func (c *Client) TestResponseIntegerInt32Nullable(ctx context.Context, request string) (res NilInt32, err error) { +// POST /test_response_integer_uint32_nullable_array_array +func (c *Client) TestResponseIntegerUint32NullableArrayArray(ctx context.Context, request string) (res [][]NilUint32, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable"), + otelogen.OperationID("test_response_integer_uint32_nullable_array_array"), } // Validate request before sending. @@ -36480,7 +40377,7 @@ func (c *Client) TestResponseIntegerInt32Nullable(ctx context.Context, request s c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36497,14 +40394,14 @@ func (c *Client) TestResponseIntegerInt32Nullable(ctx context.Context, request s stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int32_nullable" + u.Path += "/test_response_integer_uint32_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt32NullableRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint32NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36516,7 +40413,7 @@ func (c *Client) TestResponseIntegerInt32Nullable(ctx context.Context, request s defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt32NullableResponse(resp, span) + result, err := decodeTestResponseIntegerUint32NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36524,12 +40421,12 @@ func (c *Client) TestResponseIntegerInt32Nullable(ctx context.Context, request s return result, nil } -// TestResponseIntegerInt32NullableArray invokes test_response_integer_int32_nullable_array operation. +// TestResponseIntegerUint64 invokes test_response_integer_uint64 operation. // -// POST /test_response_integer_int32_nullable_array -func (c *Client) TestResponseIntegerInt32NullableArray(ctx context.Context, request string) (res []NilInt32, err error) { +// POST /test_response_integer_uint64 +func (c *Client) TestResponseIntegerUint64(ctx context.Context, request string) (res uint64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable_array"), + otelogen.OperationID("test_response_integer_uint64"), } // Validate request before sending. @@ -36544,7 +40441,7 @@ func (c *Client) TestResponseIntegerInt32NullableArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36561,14 +40458,14 @@ func (c *Client) TestResponseIntegerInt32NullableArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int32_nullable_array" + u.Path += "/test_response_integer_uint64" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt32NullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint64Request(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36580,7 +40477,7 @@ func (c *Client) TestResponseIntegerInt32NullableArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt32NullableArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint64Response(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36588,12 +40485,12 @@ func (c *Client) TestResponseIntegerInt32NullableArray(ctx context.Context, requ return result, nil } -// TestResponseIntegerInt32NullableArrayArray invokes test_response_integer_int32_nullable_array_array operation. +// TestResponseIntegerUint64Array invokes test_response_integer_uint64_array operation. // -// POST /test_response_integer_int32_nullable_array_array -func (c *Client) TestResponseIntegerInt32NullableArrayArray(ctx context.Context, request string) (res [][]NilInt32, err error) { +// POST /test_response_integer_uint64_array +func (c *Client) TestResponseIntegerUint64Array(ctx context.Context, request string) (res []uint64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint64_array"), } // Validate request before sending. @@ -36608,7 +40505,7 @@ func (c *Client) TestResponseIntegerInt32NullableArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt32NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36625,14 +40522,14 @@ func (c *Client) TestResponseIntegerInt32NullableArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int32_nullable_array_array" + u.Path += "/test_response_integer_uint64_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt32NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint64ArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36644,7 +40541,7 @@ func (c *Client) TestResponseIntegerInt32NullableArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt32NullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint64ArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36652,12 +40549,12 @@ func (c *Client) TestResponseIntegerInt32NullableArrayArray(ctx context.Context, return result, nil } -// TestResponseIntegerInt64 invokes test_response_integer_int64 operation. +// TestResponseIntegerUint64ArrayArray invokes test_response_integer_uint64_array_array operation. // -// POST /test_response_integer_int64 -func (c *Client) TestResponseIntegerInt64(ctx context.Context, request string) (res int64, err error) { +// POST /test_response_integer_uint64_array_array +func (c *Client) TestResponseIntegerUint64ArrayArray(ctx context.Context, request string) (res [][]uint64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64"), + otelogen.OperationID("test_response_integer_uint64_array_array"), } // Validate request before sending. @@ -36672,7 +40569,7 @@ func (c *Client) TestResponseIntegerInt64(ctx context.Context, request string) ( c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36689,14 +40586,14 @@ func (c *Client) TestResponseIntegerInt64(ctx context.Context, request string) ( stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int64" + u.Path += "/test_response_integer_uint64_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt64Request(request, r); err != nil { + if err := encodeTestResponseIntegerUint64ArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36708,7 +40605,7 @@ func (c *Client) TestResponseIntegerInt64(ctx context.Context, request string) ( defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt64Response(resp, span) + result, err := decodeTestResponseIntegerUint64ArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36716,12 +40613,12 @@ func (c *Client) TestResponseIntegerInt64(ctx context.Context, request string) ( return result, nil } -// TestResponseIntegerInt64Array invokes test_response_integer_int64_array operation. +// TestResponseIntegerUint64Nullable invokes test_response_integer_uint64_nullable operation. // -// POST /test_response_integer_int64_array -func (c *Client) TestResponseIntegerInt64Array(ctx context.Context, request string) (res []int64, err error) { +// POST /test_response_integer_uint64_nullable +func (c *Client) TestResponseIntegerUint64Nullable(ctx context.Context, request string) (res NilUint64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_array"), + otelogen.OperationID("test_response_integer_uint64_nullable"), } // Validate request before sending. @@ -36736,7 +40633,7 @@ func (c *Client) TestResponseIntegerInt64Array(ctx context.Context, request stri c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64Array", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36753,14 +40650,14 @@ func (c *Client) TestResponseIntegerInt64Array(ctx context.Context, request stri stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int64_array" + u.Path += "/test_response_integer_uint64_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt64ArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint64NullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36772,7 +40669,7 @@ func (c *Client) TestResponseIntegerInt64Array(ctx context.Context, request stri defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt64ArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint64NullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36780,12 +40677,12 @@ func (c *Client) TestResponseIntegerInt64Array(ctx context.Context, request stri return result, nil } -// TestResponseIntegerInt64ArrayArray invokes test_response_integer_int64_array_array operation. +// TestResponseIntegerUint64NullableArray invokes test_response_integer_uint64_nullable_array operation. // -// POST /test_response_integer_int64_array_array -func (c *Client) TestResponseIntegerInt64ArrayArray(ctx context.Context, request string) (res [][]int64, err error) { +// POST /test_response_integer_uint64_nullable_array +func (c *Client) TestResponseIntegerUint64NullableArray(ctx context.Context, request string) (res []NilUint64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_array_array"), + otelogen.OperationID("test_response_integer_uint64_nullable_array"), } // Validate request before sending. @@ -36800,7 +40697,7 @@ func (c *Client) TestResponseIntegerInt64ArrayArray(ctx context.Context, request c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64ArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36817,14 +40714,14 @@ func (c *Client) TestResponseIntegerInt64ArrayArray(ctx context.Context, request stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int64_array_array" + u.Path += "/test_response_integer_uint64_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt64ArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint64NullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36836,7 +40733,7 @@ func (c *Client) TestResponseIntegerInt64ArrayArray(ctx context.Context, request defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt64ArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUint64NullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36844,12 +40741,12 @@ func (c *Client) TestResponseIntegerInt64ArrayArray(ctx context.Context, request return result, nil } -// TestResponseIntegerInt64Nullable invokes test_response_integer_int64_nullable operation. +// TestResponseIntegerUint64NullableArrayArray invokes test_response_integer_uint64_nullable_array_array operation. // -// POST /test_response_integer_int64_nullable -func (c *Client) TestResponseIntegerInt64Nullable(ctx context.Context, request string) (res NilInt64, err error) { +// POST /test_response_integer_uint64_nullable_array_array +func (c *Client) TestResponseIntegerUint64NullableArrayArray(ctx context.Context, request string) (res [][]NilUint64, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable"), + otelogen.OperationID("test_response_integer_uint64_nullable_array_array"), } // Validate request before sending. @@ -36864,7 +40761,7 @@ func (c *Client) TestResponseIntegerInt64Nullable(ctx context.Context, request s c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64Nullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36881,14 +40778,14 @@ func (c *Client) TestResponseIntegerInt64Nullable(ctx context.Context, request s stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int64_nullable" + u.Path += "/test_response_integer_uint64_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt64NullableRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUint64NullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36900,7 +40797,7 @@ func (c *Client) TestResponseIntegerInt64Nullable(ctx context.Context, request s defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt64NullableResponse(resp, span) + result, err := decodeTestResponseIntegerUint64NullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36908,12 +40805,12 @@ func (c *Client) TestResponseIntegerInt64Nullable(ctx context.Context, request s return result, nil } -// TestResponseIntegerInt64NullableArray invokes test_response_integer_int64_nullable_array operation. +// TestResponseIntegerUintArray invokes test_response_integer_uint_array operation. // -// POST /test_response_integer_int64_nullable_array -func (c *Client) TestResponseIntegerInt64NullableArray(ctx context.Context, request string) (res []NilInt64, err error) { +// POST /test_response_integer_uint_array +func (c *Client) TestResponseIntegerUintArray(ctx context.Context, request string) (res []uint, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable_array"), + otelogen.OperationID("test_response_integer_uint_array"), } // Validate request before sending. @@ -36928,7 +40825,7 @@ func (c *Client) TestResponseIntegerInt64NullableArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64NullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUintArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -36945,14 +40842,14 @@ func (c *Client) TestResponseIntegerInt64NullableArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int64_nullable_array" + u.Path += "/test_response_integer_uint_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt64NullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUintArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -36964,7 +40861,7 @@ func (c *Client) TestResponseIntegerInt64NullableArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt64NullableArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUintArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -36972,12 +40869,12 @@ func (c *Client) TestResponseIntegerInt64NullableArray(ctx context.Context, requ return result, nil } -// TestResponseIntegerInt64NullableArrayArray invokes test_response_integer_int64_nullable_array_array operation. +// TestResponseIntegerUintArrayArray invokes test_response_integer_uint_array_array operation. // -// POST /test_response_integer_int64_nullable_array_array -func (c *Client) TestResponseIntegerInt64NullableArrayArray(ctx context.Context, request string) (res [][]NilInt64, err error) { +// POST /test_response_integer_uint_array_array +func (c *Client) TestResponseIntegerUintArrayArray(ctx context.Context, request string) (res [][]uint, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint_array_array"), } // Validate request before sending. @@ -36992,7 +40889,7 @@ func (c *Client) TestResponseIntegerInt64NullableArrayArray(ctx context.Context, c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerInt64NullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUintArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -37009,14 +40906,14 @@ func (c *Client) TestResponseIntegerInt64NullableArrayArray(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_int64_nullable_array_array" + u.Path += "/test_response_integer_uint_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerInt64NullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUintArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -37028,7 +40925,7 @@ func (c *Client) TestResponseIntegerInt64NullableArrayArray(ctx context.Context, defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerInt64NullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUintArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -37036,12 +40933,12 @@ func (c *Client) TestResponseIntegerInt64NullableArrayArray(ctx context.Context, return result, nil } -// TestResponseIntegerNullable invokes test_response_integer_nullable operation. +// TestResponseIntegerUintNullable invokes test_response_integer_uint_nullable operation. // -// POST /test_response_integer_nullable -func (c *Client) TestResponseIntegerNullable(ctx context.Context, request string) (res NilInt, err error) { +// POST /test_response_integer_uint_nullable +func (c *Client) TestResponseIntegerUintNullable(ctx context.Context, request string) (res NilUint, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable"), + otelogen.OperationID("test_response_integer_uint_nullable"), } // Validate request before sending. @@ -37056,7 +40953,7 @@ func (c *Client) TestResponseIntegerNullable(ctx context.Context, request string c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerNullable", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUintNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -37073,14 +40970,14 @@ func (c *Client) TestResponseIntegerNullable(ctx context.Context, request string stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_nullable" + u.Path += "/test_response_integer_uint_nullable" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerNullableRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUintNullableRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -37092,7 +40989,7 @@ func (c *Client) TestResponseIntegerNullable(ctx context.Context, request string defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerNullableResponse(resp, span) + result, err := decodeTestResponseIntegerUintNullableResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -37100,12 +40997,12 @@ func (c *Client) TestResponseIntegerNullable(ctx context.Context, request string return result, nil } -// TestResponseIntegerNullableArray invokes test_response_integer_nullable_array operation. +// TestResponseIntegerUintNullableArray invokes test_response_integer_uint_nullable_array operation. // -// POST /test_response_integer_nullable_array -func (c *Client) TestResponseIntegerNullableArray(ctx context.Context, request string) (res []NilInt, err error) { +// POST /test_response_integer_uint_nullable_array +func (c *Client) TestResponseIntegerUintNullableArray(ctx context.Context, request string) (res []NilUint, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable_array"), + otelogen.OperationID("test_response_integer_uint_nullable_array"), } // Validate request before sending. @@ -37120,7 +41017,7 @@ func (c *Client) TestResponseIntegerNullableArray(ctx context.Context, request s c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerNullableArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUintNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -37137,14 +41034,14 @@ func (c *Client) TestResponseIntegerNullableArray(ctx context.Context, request s stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_nullable_array" + u.Path += "/test_response_integer_uint_nullable_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerNullableArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUintNullableArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -37156,7 +41053,7 @@ func (c *Client) TestResponseIntegerNullableArray(ctx context.Context, request s defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerNullableArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUintNullableArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -37164,12 +41061,12 @@ func (c *Client) TestResponseIntegerNullableArray(ctx context.Context, request s return result, nil } -// TestResponseIntegerNullableArrayArray invokes test_response_integer_nullable_array_array operation. +// TestResponseIntegerUintNullableArrayArray invokes test_response_integer_uint_nullable_array_array operation. // -// POST /test_response_integer_nullable_array_array -func (c *Client) TestResponseIntegerNullableArrayArray(ctx context.Context, request string) (res [][]NilInt, err error) { +// POST /test_response_integer_uint_nullable_array_array +func (c *Client) TestResponseIntegerUintNullableArrayArray(ctx context.Context, request string) (res [][]NilUint, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint_nullable_array_array"), } // Validate request before sending. @@ -37184,7 +41081,7 @@ func (c *Client) TestResponseIntegerNullableArrayArray(ctx context.Context, requ c.requests.Add(ctx, 1, otelAttrs...) // Start a span for this request. - ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerNullableArrayArray", + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseIntegerUintNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindClient), ) @@ -37201,14 +41098,14 @@ func (c *Client) TestResponseIntegerNullableArrayArray(ctx context.Context, requ stage = "BuildURL" u := uri.Clone(c.serverURL) - u.Path += "/test_response_integer_nullable_array_array" + u.Path += "/test_response_integer_uint_nullable_array_array" stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u, nil) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeTestResponseIntegerNullableArrayArrayRequest(request, r); err != nil { + if err := encodeTestResponseIntegerUintNullableArrayArrayRequest(request, r); err != nil { return res, errors.Wrap(err, "encode request") } @@ -37220,7 +41117,7 @@ func (c *Client) TestResponseIntegerNullableArrayArray(ctx context.Context, requ defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeTestResponseIntegerNullableArrayArrayResponse(resp, span) + result, err := decodeTestResponseIntegerUintNullableArrayArrayResponse(resp, span) if err != nil { return res, errors.Wrap(err, "decode response") } diff --git a/examples/ex_test_format/oas_faker_gen.go b/examples/ex_test_format/oas_faker_gen.go index a5259fddb..71326e1ac 100644 --- a/examples/ex_test_format/oas_faker_gen.go +++ b/examples/ex_test_format/oas_faker_gen.go @@ -135,6 +135,21 @@ func (s *NilUUID) SetFake() { s.Null = true } +// SetFake set fake values. +func (s *NilUint) SetFake() { + s.Null = true +} + +// SetFake set fake values. +func (s *NilUint32) SetFake() { + s.Null = true +} + +// SetFake set fake values. +func (s *NilUint64) SetFake() { + s.Null = true +} + // SetFake set fake values. func (s *NilUnixMicro) SetFake() { s.Null = true @@ -401,6 +416,24 @@ func (s *OptNilUUID) SetFake() { s.Set = true } +// SetFake set fake values. +func (s *OptNilUint) SetFake() { + s.Null = true + s.Set = true +} + +// SetFake set fake values. +func (s *OptNilUint32) SetFake() { + s.Null = true + s.Set = true +} + +// SetFake set fake values. +func (s *OptNilUint64) SetFake() { + s.Null = true + s.Set = true +} + // SetFake set fake values. func (s *OptNilUnixMicro) SetFake() { s.Null = true @@ -533,6 +566,33 @@ func (s *OptUUID) SetFake() { s.SetTo(elem) } +// SetFake set fake values. +func (s *OptUint) SetFake() { + var elem uint + { + elem = uint(0) + } + s.SetTo(elem) +} + +// SetFake set fake values. +func (s *OptUint32) SetFake() { + var elem uint32 + { + elem = uint32(0) + } + s.SetTo(elem) +} + +// SetFake set fake values. +func (s *OptUint64) SetFake() { + var elem uint64 + { + elem = uint64(0) + } + s.SetTo(elem) +} + // SetFake set fake values. func (s *OptUnixMicro) SetFake() { var elem time.Time @@ -640,6 +700,42 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.RequiredArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem uint + { + elem = uint(0) + } + s.RequiredArrayIntegerUint = append(s.RequiredArrayIntegerUint, elem) + } + } + } + { + { + s.RequiredArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem uint32 + { + elem = uint32(0) + } + s.RequiredArrayIntegerUint32 = append(s.RequiredArrayIntegerUint32, elem) + } + } + } + { + { + s.RequiredArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem uint64 + { + elem = uint64(0) + } + s.RequiredArrayIntegerUint64 = append(s.RequiredArrayIntegerUint64, elem) + } + } + } { { s.RequiredArrayIntegerUnix = nil @@ -1136,6 +1232,63 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.RequiredDoubleArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem []uint + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint + { + elemElem = uint(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerUint = append(s.RequiredDoubleArrayIntegerUint, elem) + } + } + } + { + { + s.RequiredDoubleArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem []uint32 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint32 + { + elemElem = uint32(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerUint32 = append(s.RequiredDoubleArrayIntegerUint32, elem) + } + } + } + { + { + s.RequiredDoubleArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem []uint64 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint64 + { + elemElem = uint64(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerUint64 = append(s.RequiredDoubleArrayIntegerUint64, elem) + } + } + } { { s.RequiredDoubleArrayIntegerUnix = nil @@ -1778,6 +1931,21 @@ func (s *TestRequestFormatTestReq) SetFake() { s.RequiredIntegerInt64 = int64(0) } } + { + { + s.RequiredIntegerUint = uint(0) + } + } + { + { + s.RequiredIntegerUint32 = uint32(0) + } + } + { + { + s.RequiredIntegerUint64 = uint64(0) + } + } { { s.RequiredIntegerUnix = time.Now() @@ -2008,6 +2176,42 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.OptionalArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem uint + { + elem = uint(0) + } + s.OptionalArrayIntegerUint = append(s.OptionalArrayIntegerUint, elem) + } + } + } + { + { + s.OptionalArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem uint32 + { + elem = uint32(0) + } + s.OptionalArrayIntegerUint32 = append(s.OptionalArrayIntegerUint32, elem) + } + } + } + { + { + s.OptionalArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem uint64 + { + elem = uint64(0) + } + s.OptionalArrayIntegerUint64 = append(s.OptionalArrayIntegerUint64, elem) + } + } + } { { s.OptionalArrayIntegerUnix = nil @@ -2504,6 +2708,63 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.OptionalDoubleArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem []uint + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint + { + elemElem = uint(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint = append(s.OptionalDoubleArrayIntegerUint, elem) + } + } + } + { + { + s.OptionalDoubleArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem []uint32 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint32 + { + elemElem = uint32(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint32 = append(s.OptionalDoubleArrayIntegerUint32, elem) + } + } + } + { + { + s.OptionalDoubleArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem []uint64 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint64 + { + elemElem = uint64(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint64 = append(s.OptionalDoubleArrayIntegerUint64, elem) + } + } + } { { s.OptionalDoubleArrayIntegerUnix = nil @@ -3146,6 +3407,21 @@ func (s *TestRequestFormatTestReq) SetFake() { s.OptionalIntegerInt64.SetFake() } } + { + { + s.OptionalIntegerUint.SetFake() + } + } + { + { + s.OptionalIntegerUint32.SetFake() + } + } + { + { + s.OptionalIntegerUint64.SetFake() + } + } { { s.OptionalIntegerUnix.SetFake() @@ -3384,6 +3660,42 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } } } + { + { + s.RequiredArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem uint + { + elem = uint(0) + } + s.RequiredArrayIntegerUint = append(s.RequiredArrayIntegerUint, elem) + } + } + } + { + { + s.RequiredArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem uint32 + { + elem = uint32(0) + } + s.RequiredArrayIntegerUint32 = append(s.RequiredArrayIntegerUint32, elem) + } + } + } + { + { + s.RequiredArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem uint64 + { + elem = uint64(0) + } + s.RequiredArrayIntegerUint64 = append(s.RequiredArrayIntegerUint64, elem) + } + } + } { { s.RequiredArrayIntegerUnix = nil @@ -3844,39 +4156,96 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } { { - s.RequiredDoubleArrayIntegerInt32 = nil + s.RequiredDoubleArrayIntegerInt32 = nil + for i := 0; i < 0; i++ { + var elem []int32 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem int32 + { + elemElem = int32(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerInt32 = append(s.RequiredDoubleArrayIntegerInt32, elem) + } + } + } + { + { + s.RequiredDoubleArrayIntegerInt64 = nil + for i := 0; i < 0; i++ { + var elem []int64 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem int64 + { + elemElem = int64(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerInt64 = append(s.RequiredDoubleArrayIntegerInt64, elem) + } + } + } + { + { + s.RequiredDoubleArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem []uint + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint + { + elemElem = uint(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerUint = append(s.RequiredDoubleArrayIntegerUint, elem) + } + } + } + { + { + s.RequiredDoubleArrayIntegerUint32 = nil for i := 0; i < 0; i++ { - var elem []int32 + var elem []uint32 { elem = nil for i := 0; i < 0; i++ { - var elemElem int32 + var elemElem uint32 { - elemElem = int32(0) + elemElem = uint32(0) } elem = append(elem, elemElem) } } - s.RequiredDoubleArrayIntegerInt32 = append(s.RequiredDoubleArrayIntegerInt32, elem) + s.RequiredDoubleArrayIntegerUint32 = append(s.RequiredDoubleArrayIntegerUint32, elem) } } } { { - s.RequiredDoubleArrayIntegerInt64 = nil + s.RequiredDoubleArrayIntegerUint64 = nil for i := 0; i < 0; i++ { - var elem []int64 + var elem []uint64 { elem = nil for i := 0; i < 0; i++ { - var elemElem int64 + var elemElem uint64 { - elemElem = int64(0) + elemElem = uint64(0) } elem = append(elem, elemElem) } } - s.RequiredDoubleArrayIntegerInt64 = append(s.RequiredDoubleArrayIntegerInt64, elem) + s.RequiredDoubleArrayIntegerUint64 = append(s.RequiredDoubleArrayIntegerUint64, elem) } } } @@ -4522,6 +4891,21 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { s.RequiredIntegerInt64 = int64(0) } } + { + { + s.RequiredIntegerUint = uint(0) + } + } + { + { + s.RequiredIntegerUint32 = uint32(0) + } + } + { + { + s.RequiredIntegerUint64 = uint64(0) + } + } { { s.RequiredIntegerUnix = time.Now() @@ -4752,6 +5136,42 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } } } + { + { + s.OptionalArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem uint + { + elem = uint(0) + } + s.OptionalArrayIntegerUint = append(s.OptionalArrayIntegerUint, elem) + } + } + } + { + { + s.OptionalArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem uint32 + { + elem = uint32(0) + } + s.OptionalArrayIntegerUint32 = append(s.OptionalArrayIntegerUint32, elem) + } + } + } + { + { + s.OptionalArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem uint64 + { + elem = uint64(0) + } + s.OptionalArrayIntegerUint64 = append(s.OptionalArrayIntegerUint64, elem) + } + } + } { { s.OptionalArrayIntegerUnix = nil @@ -5248,6 +5668,63 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } } } + { + { + s.OptionalDoubleArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem []uint + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint + { + elemElem = uint(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint = append(s.OptionalDoubleArrayIntegerUint, elem) + } + } + } + { + { + s.OptionalDoubleArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem []uint32 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint32 + { + elemElem = uint32(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint32 = append(s.OptionalDoubleArrayIntegerUint32, elem) + } + } + } + { + { + s.OptionalDoubleArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem []uint64 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint64 + { + elemElem = uint64(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint64 = append(s.OptionalDoubleArrayIntegerUint64, elem) + } + } + } { { s.OptionalDoubleArrayIntegerUnix = nil @@ -5890,6 +6367,21 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { s.OptionalIntegerInt64.SetFake() } } + { + { + s.OptionalIntegerUint.SetFake() + } + } + { + { + s.OptionalIntegerUint32.SetFake() + } + } + { + { + s.OptionalIntegerUint64.SetFake() + } + } { { s.OptionalIntegerUnix.SetFake() @@ -6128,6 +6620,42 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.RequiredArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem uint + { + elem = uint(0) + } + s.RequiredArrayIntegerUint = append(s.RequiredArrayIntegerUint, elem) + } + } + } + { + { + s.RequiredArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem uint32 + { + elem = uint32(0) + } + s.RequiredArrayIntegerUint32 = append(s.RequiredArrayIntegerUint32, elem) + } + } + } + { + { + s.RequiredArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem uint64 + { + elem = uint64(0) + } + s.RequiredArrayIntegerUint64 = append(s.RequiredArrayIntegerUint64, elem) + } + } + } { { s.RequiredArrayIntegerUnix = nil @@ -6624,6 +7152,63 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.RequiredDoubleArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem []uint + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint + { + elemElem = uint(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerUint = append(s.RequiredDoubleArrayIntegerUint, elem) + } + } + } + { + { + s.RequiredDoubleArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem []uint32 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint32 + { + elemElem = uint32(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerUint32 = append(s.RequiredDoubleArrayIntegerUint32, elem) + } + } + } + { + { + s.RequiredDoubleArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem []uint64 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint64 + { + elemElem = uint64(0) + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayIntegerUint64 = append(s.RequiredDoubleArrayIntegerUint64, elem) + } + } + } { { s.RequiredDoubleArrayIntegerUnix = nil @@ -7266,6 +7851,21 @@ func (s *TestResponseFormatTestOK) SetFake() { s.RequiredIntegerInt64 = int64(0) } } + { + { + s.RequiredIntegerUint = uint(0) + } + } + { + { + s.RequiredIntegerUint32 = uint32(0) + } + } + { + { + s.RequiredIntegerUint64 = uint64(0) + } + } { { s.RequiredIntegerUnix = time.Now() @@ -7496,6 +8096,42 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.OptionalArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem uint + { + elem = uint(0) + } + s.OptionalArrayIntegerUint = append(s.OptionalArrayIntegerUint, elem) + } + } + } + { + { + s.OptionalArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem uint32 + { + elem = uint32(0) + } + s.OptionalArrayIntegerUint32 = append(s.OptionalArrayIntegerUint32, elem) + } + } + } + { + { + s.OptionalArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem uint64 + { + elem = uint64(0) + } + s.OptionalArrayIntegerUint64 = append(s.OptionalArrayIntegerUint64, elem) + } + } + } { { s.OptionalArrayIntegerUnix = nil @@ -7992,6 +8628,63 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.OptionalDoubleArrayIntegerUint = nil + for i := 0; i < 0; i++ { + var elem []uint + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint + { + elemElem = uint(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint = append(s.OptionalDoubleArrayIntegerUint, elem) + } + } + } + { + { + s.OptionalDoubleArrayIntegerUint32 = nil + for i := 0; i < 0; i++ { + var elem []uint32 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint32 + { + elemElem = uint32(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint32 = append(s.OptionalDoubleArrayIntegerUint32, elem) + } + } + } + { + { + s.OptionalDoubleArrayIntegerUint64 = nil + for i := 0; i < 0; i++ { + var elem []uint64 + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem uint64 + { + elemElem = uint64(0) + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayIntegerUint64 = append(s.OptionalDoubleArrayIntegerUint64, elem) + } + } + } { { s.OptionalDoubleArrayIntegerUnix = nil @@ -8634,6 +9327,21 @@ func (s *TestResponseFormatTestOK) SetFake() { s.OptionalIntegerInt64.SetFake() } } + { + { + s.OptionalIntegerUint.SetFake() + } + } + { + { + s.OptionalIntegerUint32.SetFake() + } + } + { + { + s.OptionalIntegerUint64.SetFake() + } + } { { s.OptionalIntegerUnix.SetFake() diff --git a/examples/ex_test_format/oas_handlers_gen.go b/examples/ex_test_format/oas_handlers_gen.go index 2761af6dd..7fe500134 100644 --- a/examples/ex_test_format/oas_handlers_gen.go +++ b/examples/ex_test_format/oas_handlers_gen.go @@ -99,6 +99,12 @@ func (s *Server) handleTestQueryParameterRequest(args [0]string, w http.Response "integer_int32_array": params.IntegerInt32Array, "integer_int64": params.IntegerInt64, "integer_int64_array": params.IntegerInt64Array, + "integer_uint": params.IntegerUint, + "integer_uint32": params.IntegerUint32, + "integer_uint32_array": params.IntegerUint32Array, + "integer_uint64": params.IntegerUint64, + "integer_uint64_array": params.IntegerUint64Array, + "integer_uint_array": params.IntegerUintArray, "integer_unix": params.IntegerUnix, "integer_unix-micro": params.IntegerUnixMicro, "integer_unix-micro_array": params.IntegerUnixMicroArray, @@ -2819,16 +2825,16 @@ func (s *Server) handleTestRequestIntegerNullableArrayArrayRequest(args [0]strin } } -// HandleTestRequestIntegerUnixRequest handles test_request_integer_unix operation. +// HandleTestRequestIntegerUintRequest handles test_request_integer_uint operation. // -// POST /test_request_integer_unix -func (s *Server) handleTestRequestIntegerUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint +func (s *Server) handleTestRequestIntegerUintRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix"), + otelogen.OperationID("test_request_integer_uint"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnix", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -2852,11 +2858,11 @@ func (s *Server) handleTestRequestIntegerUnixRequest(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnix", - ID: "test_request_integer_unix", + Name: "TestRequestIntegerUint", + ID: "test_request_integer_uint", } ) - request, close, err := s.decodeTestRequestIntegerUnixRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUintRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -2876,15 +2882,15 @@ func (s *Server) handleTestRequestIntegerUnixRequest(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnix", - OperationID: "test_request_integer_unix", + OperationName: "TestRequestIntegerUint", + OperationID: "test_request_integer_uint", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptUnixSeconds + Request = OptUint Params = struct{} Response = Error ) @@ -2897,11 +2903,11 @@ func (s *Server) handleTestRequestIntegerUnixRequest(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnix(ctx, request) + return s.h.TestRequestIntegerUint(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnix(ctx, request) + response, err = s.h.TestRequestIntegerUint(ctx, request) } if err != nil { recordError("Internal", err) @@ -2909,23 +2915,23 @@ func (s *Server) handleTestRequestIntegerUnixRequest(args [0]string, w http.Resp return } - if err := encodeTestRequestIntegerUnixResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUintResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixArrayRequest handles test_request_integer_unix_array operation. +// HandleTestRequestIntegerUint32Request handles test_request_integer_uint32 operation. // -// POST /test_request_integer_unix_array -func (s *Server) handleTestRequestIntegerUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint32 +func (s *Server) handleTestRequestIntegerUint32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_array"), + otelogen.OperationID("test_request_integer_uint32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -2949,11 +2955,11 @@ func (s *Server) handleTestRequestIntegerUnixArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixArray", - ID: "test_request_integer_unix_array", + Name: "TestRequestIntegerUint32", + ID: "test_request_integer_uint32", } ) - request, close, err := s.decodeTestRequestIntegerUnixArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -2973,15 +2979,15 @@ func (s *Server) handleTestRequestIntegerUnixArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixArray", - OperationID: "test_request_integer_unix_array", + OperationName: "TestRequestIntegerUint32", + OperationID: "test_request_integer_uint32", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = OptUint32 Params = struct{} Response = Error ) @@ -2994,11 +3000,11 @@ func (s *Server) handleTestRequestIntegerUnixArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixArray(ctx, request) + return s.h.TestRequestIntegerUint32(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixArray(ctx, request) + response, err = s.h.TestRequestIntegerUint32(ctx, request) } if err != nil { recordError("Internal", err) @@ -3006,23 +3012,23 @@ func (s *Server) handleTestRequestIntegerUnixArrayRequest(args [0]string, w http return } - if err := encodeTestRequestIntegerUnixArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixArrayArrayRequest handles test_request_integer_unix_array_array operation. +// HandleTestRequestIntegerUint32ArrayRequest handles test_request_integer_uint32_array operation. // -// POST /test_request_integer_unix_array_array -func (s *Server) handleTestRequestIntegerUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint32_array +func (s *Server) handleTestRequestIntegerUint32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_array_array"), + otelogen.OperationID("test_request_integer_uint32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3046,11 +3052,11 @@ func (s *Server) handleTestRequestIntegerUnixArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixArrayArray", - ID: "test_request_integer_unix_array_array", + Name: "TestRequestIntegerUint32Array", + ID: "test_request_integer_uint32_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3070,15 +3076,15 @@ func (s *Server) handleTestRequestIntegerUnixArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixArrayArray", - OperationID: "test_request_integer_unix_array_array", + OperationName: "TestRequestIntegerUint32Array", + OperationID: "test_request_integer_uint32_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = []uint32 Params = struct{} Response = Error ) @@ -3091,11 +3097,11 @@ func (s *Server) handleTestRequestIntegerUnixArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixArrayArray(ctx, request) + return s.h.TestRequestIntegerUint32Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUint32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -3103,23 +3109,23 @@ func (s *Server) handleTestRequestIntegerUnixArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestIntegerUnixArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMicroRequest handles test_request_integer_unix-micro operation. +// HandleTestRequestIntegerUint32ArrayArrayRequest handles test_request_integer_uint32_array_array operation. // -// POST /test_request_integer_unix-micro -func (s *Server) handleTestRequestIntegerUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint32_array_array +func (s *Server) handleTestRequestIntegerUint32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro"), + otelogen.OperationID("test_request_integer_uint32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicro", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3143,11 +3149,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMicro", - ID: "test_request_integer_unix-micro", + Name: "TestRequestIntegerUint32ArrayArray", + ID: "test_request_integer_uint32_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMicroRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3167,15 +3173,15 @@ func (s *Server) handleTestRequestIntegerUnixMicroRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMicro", - OperationID: "test_request_integer_unix-micro", + OperationName: "TestRequestIntegerUint32ArrayArray", + OperationID: "test_request_integer_uint32_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptUnixMicro + Request = [][]uint32 Params = struct{} Response = Error ) @@ -3188,11 +3194,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMicro(ctx, request) + return s.h.TestRequestIntegerUint32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMicro(ctx, request) + response, err = s.h.TestRequestIntegerUint32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -3200,23 +3206,23 @@ func (s *Server) handleTestRequestIntegerUnixMicroRequest(args [0]string, w http return } - if err := encodeTestRequestIntegerUnixMicroResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMicroArrayRequest handles test_request_integer_unix-micro_array operation. +// HandleTestRequestIntegerUint32NullableRequest handles test_request_integer_uint32_nullable operation. // -// POST /test_request_integer_unix-micro_array -func (s *Server) handleTestRequestIntegerUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint32_nullable +func (s *Server) handleTestRequestIntegerUint32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_array"), + otelogen.OperationID("test_request_integer_uint32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3240,11 +3246,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMicroArray", - ID: "test_request_integer_unix-micro_array", + Name: "TestRequestIntegerUint32Nullable", + ID: "test_request_integer_uint32_nullable", } ) - request, close, err := s.decodeTestRequestIntegerUnixMicroArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3264,15 +3270,15 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMicroArray", - OperationID: "test_request_integer_unix-micro_array", + OperationName: "TestRequestIntegerUint32Nullable", + OperationID: "test_request_integer_uint32_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = OptNilUint32 Params = struct{} Response = Error ) @@ -3285,11 +3291,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMicroArray(ctx, request) + return s.h.TestRequestIntegerUint32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMicroArray(ctx, request) + response, err = s.h.TestRequestIntegerUint32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -3297,23 +3303,23 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayRequest(args [0]string, w return } - if err := encodeTestRequestIntegerUnixMicroArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMicroArrayArrayRequest handles test_request_integer_unix-micro_array_array operation. +// HandleTestRequestIntegerUint32NullableArrayRequest handles test_request_integer_uint32_nullable_array operation. // -// POST /test_request_integer_unix-micro_array_array -func (s *Server) handleTestRequestIntegerUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint32_nullable_array +func (s *Server) handleTestRequestIntegerUint32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_array_array"), + otelogen.OperationID("test_request_integer_uint32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3337,11 +3343,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMicroArrayArray", - ID: "test_request_integer_unix-micro_array_array", + Name: "TestRequestIntegerUint32NullableArray", + ID: "test_request_integer_uint32_nullable_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMicroArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3361,15 +3367,15 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMicroArrayArray", - OperationID: "test_request_integer_unix-micro_array_array", + OperationName: "TestRequestIntegerUint32NullableArray", + OperationID: "test_request_integer_uint32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = []NilUint32 Params = struct{} Response = Error ) @@ -3382,11 +3388,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMicroArrayArray(ctx, request) + return s.h.TestRequestIntegerUint32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUint32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -3394,23 +3400,23 @@ func (s *Server) handleTestRequestIntegerUnixMicroArrayArrayRequest(args [0]stri return } - if err := encodeTestRequestIntegerUnixMicroArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMicroNullableRequest handles test_request_integer_unix-micro_nullable operation. +// HandleTestRequestIntegerUint32NullableArrayArrayRequest handles test_request_integer_uint32_nullable_array_array operation. // -// POST /test_request_integer_unix-micro_nullable -func (s *Server) handleTestRequestIntegerUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint32_nullable_array_array +func (s *Server) handleTestRequestIntegerUint32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_nullable"), + otelogen.OperationID("test_request_integer_uint32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3434,11 +3440,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMicroNullable", - ID: "test_request_integer_unix-micro_nullable", + Name: "TestRequestIntegerUint32NullableArrayArray", + ID: "test_request_integer_uint32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMicroNullableRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3458,15 +3464,15 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMicroNullable", - OperationID: "test_request_integer_unix-micro_nullable", + OperationName: "TestRequestIntegerUint32NullableArrayArray", + OperationID: "test_request_integer_uint32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilUnixMicro + Request = [][]NilUint32 Params = struct{} Response = Error ) @@ -3479,11 +3485,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMicroNullable(ctx, request) + return s.h.TestRequestIntegerUint32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestIntegerUint32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -3491,23 +3497,23 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableRequest(args [0]string return } - if err := encodeTestRequestIntegerUnixMicroNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMicroNullableArrayRequest handles test_request_integer_unix-micro_nullable_array operation. +// HandleTestRequestIntegerUint64Request handles test_request_integer_uint64 operation. // -// POST /test_request_integer_unix-micro_nullable_array -func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint64 +func (s *Server) handleTestRequestIntegerUint64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_nullable_array"), + otelogen.OperationID("test_request_integer_uint64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3531,11 +3537,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMicroNullableArray", - ID: "test_request_integer_unix-micro_nullable_array", + Name: "TestRequestIntegerUint64", + ID: "test_request_integer_uint64", } ) - request, close, err := s.decodeTestRequestIntegerUnixMicroNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3555,15 +3561,15 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMicroNullableArray", - OperationID: "test_request_integer_unix-micro_nullable_array", + OperationName: "TestRequestIntegerUint64", + OperationID: "test_request_integer_uint64", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixMicro + Request = OptUint64 Params = struct{} Response = Error ) @@ -3576,11 +3582,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMicroNullableArray(ctx, request) + return s.h.TestRequestIntegerUint64(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUint64(ctx, request) } if err != nil { recordError("Internal", err) @@ -3588,23 +3594,23 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayRequest(args [0]s return } - if err := encodeTestRequestIntegerUnixMicroNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMicroNullableArrayArrayRequest handles test_request_integer_unix-micro_nullable_array_array operation. +// HandleTestRequestIntegerUint64ArrayRequest handles test_request_integer_uint64_array operation. // -// POST /test_request_integer_unix-micro_nullable_array_array -func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint64_array +func (s *Server) handleTestRequestIntegerUint64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_integer_uint64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3628,11 +3634,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMicroNullableArrayArray", - ID: "test_request_integer_unix-micro_nullable_array_array", + Name: "TestRequestIntegerUint64Array", + ID: "test_request_integer_uint64_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3652,15 +3658,15 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMicroNullableArrayArray", - OperationID: "test_request_integer_unix-micro_nullable_array_array", + OperationName: "TestRequestIntegerUint64Array", + OperationID: "test_request_integer_uint64_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixMicro + Request = []uint64 Params = struct{} Response = Error ) @@ -3673,11 +3679,11 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMicroNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUint64Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUint64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -3685,23 +3691,23 @@ func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayArrayRequest(args return } - if err := encodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMilliRequest handles test_request_integer_unix-milli operation. +// HandleTestRequestIntegerUint64ArrayArrayRequest handles test_request_integer_uint64_array_array operation. // -// POST /test_request_integer_unix-milli -func (s *Server) handleTestRequestIntegerUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint64_array_array +func (s *Server) handleTestRequestIntegerUint64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli"), + otelogen.OperationID("test_request_integer_uint64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilli", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3725,11 +3731,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMilli", - ID: "test_request_integer_unix-milli", + Name: "TestRequestIntegerUint64ArrayArray", + ID: "test_request_integer_uint64_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMilliRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3749,15 +3755,15 @@ func (s *Server) handleTestRequestIntegerUnixMilliRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMilli", - OperationID: "test_request_integer_unix-milli", + OperationName: "TestRequestIntegerUint64ArrayArray", + OperationID: "test_request_integer_uint64_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptUnixMilli + Request = [][]uint64 Params = struct{} Response = Error ) @@ -3770,11 +3776,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMilli(ctx, request) + return s.h.TestRequestIntegerUint64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMilli(ctx, request) + response, err = s.h.TestRequestIntegerUint64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -3782,23 +3788,23 @@ func (s *Server) handleTestRequestIntegerUnixMilliRequest(args [0]string, w http return } - if err := encodeTestRequestIntegerUnixMilliResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMilliArrayRequest handles test_request_integer_unix-milli_array operation. +// HandleTestRequestIntegerUint64NullableRequest handles test_request_integer_uint64_nullable operation. // -// POST /test_request_integer_unix-milli_array -func (s *Server) handleTestRequestIntegerUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint64_nullable +func (s *Server) handleTestRequestIntegerUint64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_array"), + otelogen.OperationID("test_request_integer_uint64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3822,11 +3828,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMilliArray", - ID: "test_request_integer_unix-milli_array", + Name: "TestRequestIntegerUint64Nullable", + ID: "test_request_integer_uint64_nullable", } ) - request, close, err := s.decodeTestRequestIntegerUnixMilliArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3846,15 +3852,15 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMilliArray", - OperationID: "test_request_integer_unix-milli_array", + OperationName: "TestRequestIntegerUint64Nullable", + OperationID: "test_request_integer_uint64_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = OptNilUint64 Params = struct{} Response = Error ) @@ -3867,11 +3873,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMilliArray(ctx, request) + return s.h.TestRequestIntegerUint64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMilliArray(ctx, request) + response, err = s.h.TestRequestIntegerUint64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -3879,23 +3885,23 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayRequest(args [0]string, w return } - if err := encodeTestRequestIntegerUnixMilliArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMilliArrayArrayRequest handles test_request_integer_unix-milli_array_array operation. +// HandleTestRequestIntegerUint64NullableArrayRequest handles test_request_integer_uint64_nullable_array operation. // -// POST /test_request_integer_unix-milli_array_array -func (s *Server) handleTestRequestIntegerUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint64_nullable_array +func (s *Server) handleTestRequestIntegerUint64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_array_array"), + otelogen.OperationID("test_request_integer_uint64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -3919,11 +3925,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMilliArrayArray", - ID: "test_request_integer_unix-milli_array_array", + Name: "TestRequestIntegerUint64NullableArray", + ID: "test_request_integer_uint64_nullable_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMilliArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -3943,15 +3949,15 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMilliArrayArray", - OperationID: "test_request_integer_unix-milli_array_array", + OperationName: "TestRequestIntegerUint64NullableArray", + OperationID: "test_request_integer_uint64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = []NilUint64 Params = struct{} Response = Error ) @@ -3964,11 +3970,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMilliArrayArray(ctx, request) + return s.h.TestRequestIntegerUint64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUint64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -3976,23 +3982,23 @@ func (s *Server) handleTestRequestIntegerUnixMilliArrayArrayRequest(args [0]stri return } - if err := encodeTestRequestIntegerUnixMilliArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMilliNullableRequest handles test_request_integer_unix-milli_nullable operation. +// HandleTestRequestIntegerUint64NullableArrayArrayRequest handles test_request_integer_uint64_nullable_array_array operation. // -// POST /test_request_integer_unix-milli_nullable -func (s *Server) handleTestRequestIntegerUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint64_nullable_array_array +func (s *Server) handleTestRequestIntegerUint64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_nullable"), + otelogen.OperationID("test_request_integer_uint64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4016,11 +4022,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMilliNullable", - ID: "test_request_integer_unix-milli_nullable", + Name: "TestRequestIntegerUint64NullableArrayArray", + ID: "test_request_integer_uint64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMilliNullableRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUint64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4040,15 +4046,15 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMilliNullable", - OperationID: "test_request_integer_unix-milli_nullable", + OperationName: "TestRequestIntegerUint64NullableArrayArray", + OperationID: "test_request_integer_uint64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilUnixMilli + Request = [][]NilUint64 Params = struct{} Response = Error ) @@ -4061,11 +4067,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMilliNullable(ctx, request) + return s.h.TestRequestIntegerUint64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestIntegerUint64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -4073,23 +4079,23 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableRequest(args [0]string return } - if err := encodeTestRequestIntegerUnixMilliNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUint64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMilliNullableArrayRequest handles test_request_integer_unix-milli_nullable_array operation. +// HandleTestRequestIntegerUintArrayRequest handles test_request_integer_uint_array operation. // -// POST /test_request_integer_unix-milli_nullable_array -func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint_array +func (s *Server) handleTestRequestIntegerUintArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_nullable_array"), + otelogen.OperationID("test_request_integer_uint_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUintArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4113,11 +4119,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMilliNullableArray", - ID: "test_request_integer_unix-milli_nullable_array", + Name: "TestRequestIntegerUintArray", + ID: "test_request_integer_uint_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMilliNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUintArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4137,15 +4143,15 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMilliNullableArray", - OperationID: "test_request_integer_unix-milli_nullable_array", + OperationName: "TestRequestIntegerUintArray", + OperationID: "test_request_integer_uint_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixMilli + Request = []uint Params = struct{} Response = Error ) @@ -4158,11 +4164,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMilliNullableArray(ctx, request) + return s.h.TestRequestIntegerUintArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUintArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -4170,23 +4176,23 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayRequest(args [0]s return } - if err := encodeTestRequestIntegerUnixMilliNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUintArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixMilliNullableArrayArrayRequest handles test_request_integer_unix-milli_nullable_array_array operation. +// HandleTestRequestIntegerUintArrayArrayRequest handles test_request_integer_uint_array_array operation. // -// POST /test_request_integer_unix-milli_nullable_array_array -func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint_array_array +func (s *Server) handleTestRequestIntegerUintArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_integer_uint_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUintArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4210,11 +4216,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixMilliNullableArrayArray", - ID: "test_request_integer_unix-milli_nullable_array_array", + Name: "TestRequestIntegerUintArrayArray", + ID: "test_request_integer_uint_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUintArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4234,15 +4240,15 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixMilliNullableArrayArray", - OperationID: "test_request_integer_unix-milli_nullable_array_array", + OperationName: "TestRequestIntegerUintArrayArray", + OperationID: "test_request_integer_uint_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixMilli + Request = [][]uint Params = struct{} Response = Error ) @@ -4255,11 +4261,11 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixMilliNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUintArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUintArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -4267,23 +4273,23 @@ func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayArrayRequest(args return } - if err := encodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUintArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNanoRequest handles test_request_integer_unix-nano operation. +// HandleTestRequestIntegerUintNullableRequest handles test_request_integer_uint_nullable operation. // -// POST /test_request_integer_unix-nano -func (s *Server) handleTestRequestIntegerUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint_nullable +func (s *Server) handleTestRequestIntegerUintNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano"), + otelogen.OperationID("test_request_integer_uint_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNano", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUintNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4307,11 +4313,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNano", - ID: "test_request_integer_unix-nano", + Name: "TestRequestIntegerUintNullable", + ID: "test_request_integer_uint_nullable", } ) - request, close, err := s.decodeTestRequestIntegerUnixNanoRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUintNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4331,15 +4337,15 @@ func (s *Server) handleTestRequestIntegerUnixNanoRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNano", - OperationID: "test_request_integer_unix-nano", + OperationName: "TestRequestIntegerUintNullable", + OperationID: "test_request_integer_uint_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptUnixNano + Request = OptNilUint Params = struct{} Response = Error ) @@ -4352,11 +4358,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNano(ctx, request) + return s.h.TestRequestIntegerUintNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNano(ctx, request) + response, err = s.h.TestRequestIntegerUintNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -4364,23 +4370,23 @@ func (s *Server) handleTestRequestIntegerUnixNanoRequest(args [0]string, w http. return } - if err := encodeTestRequestIntegerUnixNanoResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUintNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNanoArrayRequest handles test_request_integer_unix-nano_array operation. +// HandleTestRequestIntegerUintNullableArrayRequest handles test_request_integer_uint_nullable_array operation. // -// POST /test_request_integer_unix-nano_array -func (s *Server) handleTestRequestIntegerUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint_nullable_array +func (s *Server) handleTestRequestIntegerUintNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_array"), + otelogen.OperationID("test_request_integer_uint_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUintNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4404,11 +4410,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNanoArray", - ID: "test_request_integer_unix-nano_array", + Name: "TestRequestIntegerUintNullableArray", + ID: "test_request_integer_uint_nullable_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixNanoArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUintNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4428,15 +4434,15 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNanoArray", - OperationID: "test_request_integer_unix-nano_array", + OperationName: "TestRequestIntegerUintNullableArray", + OperationID: "test_request_integer_uint_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilUint Params = struct{} Response = Error ) @@ -4449,11 +4455,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNanoArray(ctx, request) + return s.h.TestRequestIntegerUintNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNanoArray(ctx, request) + response, err = s.h.TestRequestIntegerUintNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -4461,23 +4467,23 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayRequest(args [0]string, w return } - if err := encodeTestRequestIntegerUnixNanoArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUintNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNanoArrayArrayRequest handles test_request_integer_unix-nano_array_array operation. +// HandleTestRequestIntegerUintNullableArrayArrayRequest handles test_request_integer_uint_nullable_array_array operation. // -// POST /test_request_integer_unix-nano_array_array -func (s *Server) handleTestRequestIntegerUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_uint_nullable_array_array +func (s *Server) handleTestRequestIntegerUintNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_array_array"), + otelogen.OperationID("test_request_integer_uint_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUintNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4501,11 +4507,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNanoArrayArray", - ID: "test_request_integer_unix-nano_array_array", + Name: "TestRequestIntegerUintNullableArrayArray", + ID: "test_request_integer_uint_nullable_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixNanoArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUintNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4525,15 +4531,15 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNanoArrayArray", - OperationID: "test_request_integer_unix-nano_array_array", + OperationName: "TestRequestIntegerUintNullableArrayArray", + OperationID: "test_request_integer_uint_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilUint Params = struct{} Response = Error ) @@ -4546,11 +4552,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNanoArrayArray(ctx, request) + return s.h.TestRequestIntegerUintNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUintNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -4558,23 +4564,23 @@ func (s *Server) handleTestRequestIntegerUnixNanoArrayArrayRequest(args [0]strin return } - if err := encodeTestRequestIntegerUnixNanoArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUintNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNanoNullableRequest handles test_request_integer_unix-nano_nullable operation. +// HandleTestRequestIntegerUnixRequest handles test_request_integer_unix operation. // -// POST /test_request_integer_unix-nano_nullable -func (s *Server) handleTestRequestIntegerUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix +func (s *Server) handleTestRequestIntegerUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_nullable"), + otelogen.OperationID("test_request_integer_unix"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnix", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4598,108 +4604,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNanoNullable", - ID: "test_request_integer_unix-nano_nullable", - } - ) - request, close, err := s.decodeTestRequestIntegerUnixNanoNullableRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestIntegerUnixNanoNullable", - OperationID: "test_request_integer_unix-nano_nullable", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = OptNilUnixNano - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNanoNullable(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestIntegerUnixNanoNullable(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestIntegerUnixNanoNullableResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestIntegerUnixNanoNullableArrayRequest handles test_request_integer_unix-nano_nullable_array operation. -// -// POST /test_request_integer_unix-nano_nullable_array -func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_nullable_array"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoNullableArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNanoNullableArray", - ID: "test_request_integer_unix-nano_nullable_array", + Name: "TestRequestIntegerUnix", + ID: "test_request_integer_unix", } ) - request, close, err := s.decodeTestRequestIntegerUnixNanoNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4719,15 +4628,15 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNanoNullableArray", - OperationID: "test_request_integer_unix-nano_nullable_array", + OperationName: "TestRequestIntegerUnix", + OperationID: "test_request_integer_unix", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixNano + Request = OptUnixSeconds Params = struct{} Response = Error ) @@ -4740,11 +4649,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNanoNullableArray(ctx, request) + return s.h.TestRequestIntegerUnix(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUnix(ctx, request) } if err != nil { recordError("Internal", err) @@ -4752,23 +4661,23 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayRequest(args [0]st return } - if err := encodeTestRequestIntegerUnixNanoNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNanoNullableArrayArrayRequest handles test_request_integer_unix-nano_nullable_array_array operation. +// HandleTestRequestIntegerUnixArrayRequest handles test_request_integer_unix_array operation. // -// POST /test_request_integer_unix-nano_nullable_array_array -func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix_array +func (s *Server) handleTestRequestIntegerUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4792,11 +4701,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNanoNullableArrayArray", - ID: "test_request_integer_unix-nano_nullable_array_array", + Name: "TestRequestIntegerUnixArray", + ID: "test_request_integer_unix_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4816,15 +4725,15 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNanoNullableArrayArray", - OperationID: "test_request_integer_unix-nano_nullable_array_array", + OperationName: "TestRequestIntegerUnixArray", + OperationID: "test_request_integer_unix_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixNano + Request = []time.Time Params = struct{} Response = Error ) @@ -4837,11 +4746,11 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNanoNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -4849,23 +4758,23 @@ func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayArrayRequest(args return } - if err := encodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNullableRequest handles test_request_integer_unix_nullable operation. +// HandleTestRequestIntegerUnixArrayArrayRequest handles test_request_integer_unix_array_array operation. // -// POST /test_request_integer_unix_nullable -func (s *Server) handleTestRequestIntegerUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix_array_array +func (s *Server) handleTestRequestIntegerUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_nullable"), + otelogen.OperationID("test_request_integer_unix_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4889,11 +4798,11 @@ func (s *Server) handleTestRequestIntegerUnixNullableRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNullable", - ID: "test_request_integer_unix_nullable", + Name: "TestRequestIntegerUnixArrayArray", + ID: "test_request_integer_unix_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixNullableRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -4913,15 +4822,15 @@ func (s *Server) handleTestRequestIntegerUnixNullableRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNullable", - OperationID: "test_request_integer_unix_nullable", + OperationName: "TestRequestIntegerUnixArrayArray", + OperationID: "test_request_integer_unix_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilUnixSeconds + Request = [][]time.Time Params = struct{} Response = Error ) @@ -4934,11 +4843,11 @@ func (s *Server) handleTestRequestIntegerUnixNullableRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNullable(ctx, request) + return s.h.TestRequestIntegerUnixArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNullable(ctx, request) + response, err = s.h.TestRequestIntegerUnixArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -4946,23 +4855,23 @@ func (s *Server) handleTestRequestIntegerUnixNullableRequest(args [0]string, w h return } - if err := encodeTestRequestIntegerUnixNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNullableArrayRequest handles test_request_integer_unix_nullable_array operation. +// HandleTestRequestIntegerUnixMicroRequest handles test_request_integer_unix-micro operation. // -// POST /test_request_integer_unix_nullable_array -func (s *Server) handleTestRequestIntegerUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-micro +func (s *Server) handleTestRequestIntegerUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_nullable_array"), + otelogen.OperationID("test_request_integer_unix-micro"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicro", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -4986,11 +4895,11 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNullableArray", - ID: "test_request_integer_unix_nullable_array", + Name: "TestRequestIntegerUnixMicro", + ID: "test_request_integer_unix-micro", } ) - request, close, err := s.decodeTestRequestIntegerUnixNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMicroRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5010,15 +4919,15 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNullableArray", - OperationID: "test_request_integer_unix_nullable_array", + OperationName: "TestRequestIntegerUnixMicro", + OperationID: "test_request_integer_unix-micro", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixSeconds + Request = OptUnixMicro Params = struct{} Response = Error ) @@ -5031,11 +4940,11 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNullableArray(ctx, request) + return s.h.TestRequestIntegerUnixMicro(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMicro(ctx, request) } if err != nil { recordError("Internal", err) @@ -5043,23 +4952,23 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayRequest(args [0]string return } - if err := encodeTestRequestIntegerUnixNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMicroResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixNullableArrayArrayRequest handles test_request_integer_unix_nullable_array_array operation. +// HandleTestRequestIntegerUnixMicroArrayRequest handles test_request_integer_unix-micro_array operation. // -// POST /test_request_integer_unix_nullable_array_array -func (s *Server) handleTestRequestIntegerUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-micro_array +func (s *Server) handleTestRequestIntegerUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix-micro_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5083,11 +4992,11 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixNullableArrayArray", - ID: "test_request_integer_unix_nullable_array_array", + Name: "TestRequestIntegerUnixMicroArray", + ID: "test_request_integer_unix-micro_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMicroArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5107,15 +5016,15 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixNullableArrayArray", - OperationID: "test_request_integer_unix_nullable_array_array", + OperationName: "TestRequestIntegerUnixMicroArray", + OperationID: "test_request_integer_unix-micro_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixSeconds + Request = []time.Time Params = struct{} Response = Error ) @@ -5128,11 +5037,11 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixMicroArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMicroArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -5140,23 +5049,23 @@ func (s *Server) handleTestRequestIntegerUnixNullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestIntegerUnixNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMicroArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixSecondsRequest handles test_request_integer_unix-seconds operation. +// HandleTestRequestIntegerUnixMicroArrayArrayRequest handles test_request_integer_unix-micro_array_array operation. // -// POST /test_request_integer_unix-seconds -func (s *Server) handleTestRequestIntegerUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-micro_array_array +func (s *Server) handleTestRequestIntegerUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds"), + otelogen.OperationID("test_request_integer_unix-micro_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSeconds", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5180,11 +5089,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixSeconds", - ID: "test_request_integer_unix-seconds", + Name: "TestRequestIntegerUnixMicroArrayArray", + ID: "test_request_integer_unix-micro_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixSecondsRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMicroArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5204,15 +5113,15 @@ func (s *Server) handleTestRequestIntegerUnixSecondsRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixSeconds", - OperationID: "test_request_integer_unix-seconds", + OperationName: "TestRequestIntegerUnixMicroArrayArray", + OperationID: "test_request_integer_unix-micro_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptUnixSeconds + Request = [][]time.Time Params = struct{} Response = Error ) @@ -5225,11 +5134,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixSeconds(ctx, request) + return s.h.TestRequestIntegerUnixMicroArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixSeconds(ctx, request) + response, err = s.h.TestRequestIntegerUnixMicroArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -5237,23 +5146,23 @@ func (s *Server) handleTestRequestIntegerUnixSecondsRequest(args [0]string, w ht return } - if err := encodeTestRequestIntegerUnixSecondsResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMicroArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixSecondsArrayRequest handles test_request_integer_unix-seconds_array operation. +// HandleTestRequestIntegerUnixMicroNullableRequest handles test_request_integer_unix-micro_nullable operation. // -// POST /test_request_integer_unix-seconds_array -func (s *Server) handleTestRequestIntegerUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-micro_nullable +func (s *Server) handleTestRequestIntegerUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_array"), + otelogen.OperationID("test_request_integer_unix-micro_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5277,108 +5186,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixSecondsArray", - ID: "test_request_integer_unix-seconds_array", - } - ) - request, close, err := s.decodeTestRequestIntegerUnixSecondsArrayRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestIntegerUnixSecondsArray", - OperationID: "test_request_integer_unix-seconds_array", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = []time.Time - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixSecondsArray(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestIntegerUnixSecondsArray(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestIntegerUnixSecondsArrayResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestIntegerUnixSecondsArrayArrayRequest handles test_request_integer_unix-seconds_array_array operation. -// -// POST /test_request_integer_unix-seconds_array_array -func (s *Server) handleTestRequestIntegerUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_array_array"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsArrayArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixSecondsArrayArray", - ID: "test_request_integer_unix-seconds_array_array", + Name: "TestRequestIntegerUnixMicroNullable", + ID: "test_request_integer_unix-micro_nullable", } ) - request, close, err := s.decodeTestRequestIntegerUnixSecondsArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMicroNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5398,15 +5210,15 @@ func (s *Server) handleTestRequestIntegerUnixSecondsArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixSecondsArrayArray", - OperationID: "test_request_integer_unix-seconds_array_array", + OperationName: "TestRequestIntegerUnixMicroNullable", + OperationID: "test_request_integer_unix-micro_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = OptNilUnixMicro Params = struct{} Response = Error ) @@ -5419,11 +5231,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixSecondsArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixMicroNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMicroNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -5431,23 +5243,23 @@ func (s *Server) handleTestRequestIntegerUnixSecondsArrayArrayRequest(args [0]st return } - if err := encodeTestRequestIntegerUnixSecondsArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMicroNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixSecondsNullableRequest handles test_request_integer_unix-seconds_nullable operation. +// HandleTestRequestIntegerUnixMicroNullableArrayRequest handles test_request_integer_unix-micro_nullable_array operation. // -// POST /test_request_integer_unix-seconds_nullable -func (s *Server) handleTestRequestIntegerUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-micro_nullable_array +func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_nullable"), + otelogen.OperationID("test_request_integer_unix-micro_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5471,11 +5283,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixSecondsNullable", - ID: "test_request_integer_unix-seconds_nullable", + Name: "TestRequestIntegerUnixMicroNullableArray", + ID: "test_request_integer_unix-micro_nullable_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixSecondsNullableRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMicroNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5495,15 +5307,15 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixSecondsNullable", - OperationID: "test_request_integer_unix-seconds_nullable", + OperationName: "TestRequestIntegerUnixMicroNullableArray", + OperationID: "test_request_integer_unix-micro_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilUnixSeconds + Request = []NilUnixMicro Params = struct{} Response = Error ) @@ -5516,11 +5328,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixSecondsNullable(ctx, request) + return s.h.TestRequestIntegerUnixMicroNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestIntegerUnixMicroNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -5528,23 +5340,23 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableRequest(args [0]stri return } - if err := encodeTestRequestIntegerUnixSecondsNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMicroNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixSecondsNullableArrayRequest handles test_request_integer_unix-seconds_nullable_array operation. +// HandleTestRequestIntegerUnixMicroNullableArrayArrayRequest handles test_request_integer_unix-micro_nullable_array_array operation. // -// POST /test_request_integer_unix-seconds_nullable_array -func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-micro_nullable_array_array +func (s *Server) handleTestRequestIntegerUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_integer_unix-micro_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5568,11 +5380,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixSecondsNullableArray", - ID: "test_request_integer_unix-seconds_nullable_array", + Name: "TestRequestIntegerUnixMicroNullableArrayArray", + ID: "test_request_integer_unix-micro_nullable_array_array", } ) - request, close, err := s.decodeTestRequestIntegerUnixSecondsNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5592,15 +5404,15 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixSecondsNullableArray", - OperationID: "test_request_integer_unix-seconds_nullable_array", + OperationName: "TestRequestIntegerUnixMicroNullableArrayArray", + OperationID: "test_request_integer_unix-micro_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixSeconds + Request = [][]NilUnixMicro Params = struct{} Response = Error ) @@ -5613,11 +5425,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixSecondsNullableArray(ctx, request) + return s.h.TestRequestIntegerUnixMicroNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMicroNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -5625,23 +5437,23 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayRequest(args [0 return } - if err := encodeTestRequestIntegerUnixSecondsNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestIntegerUnixSecondsNullableArrayArrayRequest handles test_request_integer_unix-seconds_nullable_array_array operation. +// HandleTestRequestIntegerUnixMilliRequest handles test_request_integer_unix-milli operation. // -// POST /test_request_integer_unix-seconds_nullable_array_array -func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-milli +func (s *Server) handleTestRequestIntegerUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_integer_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix-milli"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilli", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5665,11 +5477,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestIntegerUnixSecondsNullableArrayArray", - ID: "test_request_integer_unix-seconds_nullable_array_array", + Name: "TestRequestIntegerUnixMilli", + ID: "test_request_integer_unix-milli", } ) - request, close, err := s.decodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMilliRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5689,15 +5501,15 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestIntegerUnixSecondsNullableArrayArray", - OperationID: "test_request_integer_unix-seconds_nullable_array_array", + OperationName: "TestRequestIntegerUnixMilli", + OperationID: "test_request_integer_unix-milli", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixSeconds + Request = OptUnixMilli Params = struct{} Response = Error ) @@ -5710,11 +5522,11 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestIntegerUnixSecondsNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixMilli(ctx, request) }, ) } else { - response, err = s.h.TestRequestIntegerUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMilli(ctx, request) } if err != nil { recordError("Internal", err) @@ -5722,23 +5534,23 @@ func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest(ar return } - if err := encodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMilliResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNullRequest handles test_request_null operation. +// HandleTestRequestIntegerUnixMilliArrayRequest handles test_request_integer_unix-milli_array operation. // -// POST /test_request_null -func (s *Server) handleTestRequestNullRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-milli_array +func (s *Server) handleTestRequestIntegerUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null"), + otelogen.OperationID("test_request_integer_unix-milli_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNull", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5762,11 +5574,11 @@ func (s *Server) handleTestRequestNullRequest(args [0]string, w http.ResponseWri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNull", - ID: "test_request_null", + Name: "TestRequestIntegerUnixMilliArray", + ID: "test_request_integer_unix-milli_array", } ) - request, close, err := s.decodeTestRequestNullRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMilliArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5786,15 +5598,15 @@ func (s *Server) handleTestRequestNullRequest(args [0]string, w http.ResponseWri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNull", - OperationID: "test_request_null", + OperationName: "TestRequestIntegerUnixMilliArray", + OperationID: "test_request_integer_unix-milli_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNull + Request = []time.Time Params = struct{} Response = Error ) @@ -5807,11 +5619,11 @@ func (s *Server) handleTestRequestNullRequest(args [0]string, w http.ResponseWri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNull(ctx, request) + return s.h.TestRequestIntegerUnixMilliArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNull(ctx, request) + response, err = s.h.TestRequestIntegerUnixMilliArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -5819,23 +5631,23 @@ func (s *Server) handleTestRequestNullRequest(args [0]string, w http.ResponseWri return } - if err := encodeTestRequestNullResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMilliArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNullArrayRequest handles test_request_null_array operation. +// HandleTestRequestIntegerUnixMilliArrayArrayRequest handles test_request_integer_unix-milli_array_array operation. // -// POST /test_request_null_array -func (s *Server) handleTestRequestNullArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-milli_array_array +func (s *Server) handleTestRequestIntegerUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_array"), + otelogen.OperationID("test_request_integer_unix-milli_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5859,11 +5671,11 @@ func (s *Server) handleTestRequestNullArrayRequest(args [0]string, w http.Respon } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNullArray", - ID: "test_request_null_array", + Name: "TestRequestIntegerUnixMilliArrayArray", + ID: "test_request_integer_unix-milli_array_array", } ) - request, close, err := s.decodeTestRequestNullArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMilliArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -5883,15 +5695,15 @@ func (s *Server) handleTestRequestNullArrayRequest(args [0]string, w http.Respon if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNullArray", - OperationID: "test_request_null_array", + OperationName: "TestRequestIntegerUnixMilliArrayArray", + OperationID: "test_request_integer_unix-milli_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []struct{} + Request = [][]time.Time Params = struct{} Response = Error ) @@ -5904,11 +5716,11 @@ func (s *Server) handleTestRequestNullArrayRequest(args [0]string, w http.Respon mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNullArray(ctx, request) + return s.h.TestRequestIntegerUnixMilliArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNullArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMilliArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -5916,23 +5728,23 @@ func (s *Server) handleTestRequestNullArrayRequest(args [0]string, w http.Respon return } - if err := encodeTestRequestNullArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMilliArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNullArrayArrayRequest handles test_request_null_array_array operation. +// HandleTestRequestIntegerUnixMilliNullableRequest handles test_request_integer_unix-milli_nullable operation. // -// POST /test_request_null_array_array -func (s *Server) handleTestRequestNullArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-milli_nullable +func (s *Server) handleTestRequestIntegerUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_array_array"), + otelogen.OperationID("test_request_integer_unix-milli_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -5956,108 +5768,11 @@ func (s *Server) handleTestRequestNullArrayArrayRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNullArrayArray", - ID: "test_request_null_array_array", - } - ) - request, close, err := s.decodeTestRequestNullArrayArrayRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestNullArrayArray", - OperationID: "test_request_null_array_array", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = [][]struct{} - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNullArrayArray(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestNullArrayArray(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestNullArrayArrayResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestNullNullableRequest handles test_request_null_nullable operation. -// -// POST /test_request_null_nullable -func (s *Server) handleTestRequestNullNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_nullable"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullNullable", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNullNullable", - ID: "test_request_null_nullable", + Name: "TestRequestIntegerUnixMilliNullable", + ID: "test_request_integer_unix-milli_nullable", } ) - request, close, err := s.decodeTestRequestNullNullableRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMilliNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6077,15 +5792,15 @@ func (s *Server) handleTestRequestNullNullableRequest(args [0]string, w http.Res if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNullNullable", - OperationID: "test_request_null_nullable", + OperationName: "TestRequestIntegerUnixMilliNullable", + OperationID: "test_request_integer_unix-milli_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNull + Request = OptNilUnixMilli Params = struct{} Response = Error ) @@ -6098,11 +5813,11 @@ func (s *Server) handleTestRequestNullNullableRequest(args [0]string, w http.Res mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNullNullable(ctx, request) + return s.h.TestRequestIntegerUnixMilliNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestNullNullable(ctx, request) + response, err = s.h.TestRequestIntegerUnixMilliNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -6110,23 +5825,23 @@ func (s *Server) handleTestRequestNullNullableRequest(args [0]string, w http.Res return } - if err := encodeTestRequestNullNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMilliNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNullNullableArrayRequest handles test_request_null_nullable_array operation. +// HandleTestRequestIntegerUnixMilliNullableArrayRequest handles test_request_integer_unix-milli_nullable_array operation. // -// POST /test_request_null_nullable_array -func (s *Server) handleTestRequestNullNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-milli_nullable_array +func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_nullable_array"), + otelogen.OperationID("test_request_integer_unix-milli_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6150,11 +5865,11 @@ func (s *Server) handleTestRequestNullNullableArrayRequest(args [0]string, w htt } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNullNullableArray", - ID: "test_request_null_nullable_array", + Name: "TestRequestIntegerUnixMilliNullableArray", + ID: "test_request_integer_unix-milli_nullable_array", } ) - request, close, err := s.decodeTestRequestNullNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMilliNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6174,15 +5889,15 @@ func (s *Server) handleTestRequestNullNullableArrayRequest(args [0]string, w htt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNullNullableArray", - OperationID: "test_request_null_nullable_array", + OperationName: "TestRequestIntegerUnixMilliNullableArray", + OperationID: "test_request_integer_unix-milli_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []struct{} + Request = []NilUnixMilli Params = struct{} Response = Error ) @@ -6195,11 +5910,11 @@ func (s *Server) handleTestRequestNullNullableArrayRequest(args [0]string, w htt mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNullNullableArray(ctx, request) + return s.h.TestRequestIntegerUnixMilliNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNullNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMilliNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -6207,23 +5922,23 @@ func (s *Server) handleTestRequestNullNullableArrayRequest(args [0]string, w htt return } - if err := encodeTestRequestNullNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMilliNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNullNullableArrayArrayRequest handles test_request_null_nullable_array_array operation. +// HandleTestRequestIntegerUnixMilliNullableArrayArrayRequest handles test_request_integer_unix-milli_nullable_array_array operation. // -// POST /test_request_null_nullable_array_array -func (s *Server) handleTestRequestNullNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-milli_nullable_array_array +func (s *Server) handleTestRequestIntegerUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_null_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix-milli_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6247,11 +5962,11 @@ func (s *Server) handleTestRequestNullNullableArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNullNullableArrayArray", - ID: "test_request_null_nullable_array_array", + Name: "TestRequestIntegerUnixMilliNullableArrayArray", + ID: "test_request_integer_unix-milli_nullable_array_array", } ) - request, close, err := s.decodeTestRequestNullNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6271,15 +5986,15 @@ func (s *Server) handleTestRequestNullNullableArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNullNullableArrayArray", - OperationID: "test_request_null_nullable_array_array", + OperationName: "TestRequestIntegerUnixMilliNullableArrayArray", + OperationID: "test_request_integer_unix-milli_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]struct{} + Request = [][]NilUnixMilli Params = struct{} Response = Error ) @@ -6292,11 +6007,11 @@ func (s *Server) handleTestRequestNullNullableArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNullNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixMilliNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNullNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixMilliNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -6304,23 +6019,23 @@ func (s *Server) handleTestRequestNullNullableArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestNullNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberRequest handles test_request_number operation. +// HandleTestRequestIntegerUnixNanoRequest handles test_request_integer_unix-nano operation. // -// POST /test_request_number -func (s *Server) handleTestRequestNumberRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-nano +func (s *Server) handleTestRequestIntegerUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number"), + otelogen.OperationID("test_request_integer_unix-nano"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumber", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNano", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6344,11 +6059,11 @@ func (s *Server) handleTestRequestNumberRequest(args [0]string, w http.ResponseW } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumber", - ID: "test_request_number", + Name: "TestRequestIntegerUnixNano", + ID: "test_request_integer_unix-nano", } ) - request, close, err := s.decodeTestRequestNumberRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNanoRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6368,15 +6083,15 @@ func (s *Server) handleTestRequestNumberRequest(args [0]string, w http.ResponseW if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumber", - OperationID: "test_request_number", + OperationName: "TestRequestIntegerUnixNano", + OperationID: "test_request_integer_unix-nano", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptFloat64 + Request = OptUnixNano Params = struct{} Response = Error ) @@ -6389,11 +6104,11 @@ func (s *Server) handleTestRequestNumberRequest(args [0]string, w http.ResponseW mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumber(ctx, request) + return s.h.TestRequestIntegerUnixNano(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumber(ctx, request) + response, err = s.h.TestRequestIntegerUnixNano(ctx, request) } if err != nil { recordError("Internal", err) @@ -6401,23 +6116,23 @@ func (s *Server) handleTestRequestNumberRequest(args [0]string, w http.ResponseW return } - if err := encodeTestRequestNumberResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNanoResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberArrayRequest handles test_request_number_array operation. +// HandleTestRequestIntegerUnixNanoArrayRequest handles test_request_integer_unix-nano_array operation. // -// POST /test_request_number_array -func (s *Server) handleTestRequestNumberArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-nano_array +func (s *Server) handleTestRequestIntegerUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_array"), + otelogen.OperationID("test_request_integer_unix-nano_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6441,11 +6156,11 @@ func (s *Server) handleTestRequestNumberArrayRequest(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberArray", - ID: "test_request_number_array", + Name: "TestRequestIntegerUnixNanoArray", + ID: "test_request_integer_unix-nano_array", } ) - request, close, err := s.decodeTestRequestNumberArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNanoArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6465,15 +6180,15 @@ func (s *Server) handleTestRequestNumberArrayRequest(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberArray", - OperationID: "test_request_number_array", + OperationName: "TestRequestIntegerUnixNanoArray", + OperationID: "test_request_integer_unix-nano_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []float64 + Request = []time.Time Params = struct{} Response = Error ) @@ -6486,11 +6201,11 @@ func (s *Server) handleTestRequestNumberArrayRequest(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberArray(ctx, request) + return s.h.TestRequestIntegerUnixNanoArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixNanoArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -6498,23 +6213,23 @@ func (s *Server) handleTestRequestNumberArrayRequest(args [0]string, w http.Resp return } - if err := encodeTestRequestNumberArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNanoArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberArrayArrayRequest handles test_request_number_array_array operation. +// HandleTestRequestIntegerUnixNanoArrayArrayRequest handles test_request_integer_unix-nano_array_array operation. // -// POST /test_request_number_array_array -func (s *Server) handleTestRequestNumberArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-nano_array_array +func (s *Server) handleTestRequestIntegerUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_array_array"), + otelogen.OperationID("test_request_integer_unix-nano_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6538,11 +6253,11 @@ func (s *Server) handleTestRequestNumberArrayArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberArrayArray", - ID: "test_request_number_array_array", + Name: "TestRequestIntegerUnixNanoArrayArray", + ID: "test_request_integer_unix-nano_array_array", } ) - request, close, err := s.decodeTestRequestNumberArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNanoArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6562,15 +6277,15 @@ func (s *Server) handleTestRequestNumberArrayArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberArrayArray", - OperationID: "test_request_number_array_array", + OperationName: "TestRequestIntegerUnixNanoArrayArray", + OperationID: "test_request_integer_unix-nano_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]float64 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -6583,11 +6298,11 @@ func (s *Server) handleTestRequestNumberArrayArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixNanoArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixNanoArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -6595,23 +6310,23 @@ func (s *Server) handleTestRequestNumberArrayArrayRequest(args [0]string, w http return } - if err := encodeTestRequestNumberArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNanoArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberDoubleRequest handles test_request_number_double operation. +// HandleTestRequestIntegerUnixNanoNullableRequest handles test_request_integer_unix-nano_nullable operation. // -// POST /test_request_number_double -func (s *Server) handleTestRequestNumberDoubleRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-nano_nullable +func (s *Server) handleTestRequestIntegerUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double"), + otelogen.OperationID("test_request_integer_unix-nano_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDouble", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6635,108 +6350,11 @@ func (s *Server) handleTestRequestNumberDoubleRequest(args [0]string, w http.Res } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberDouble", - ID: "test_request_number_double", - } - ) - request, close, err := s.decodeTestRequestNumberDoubleRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestNumberDouble", - OperationID: "test_request_number_double", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = OptFloat64 - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberDouble(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestNumberDouble(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestNumberDoubleResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestNumberDoubleArrayRequest handles test_request_number_double_array operation. -// -// POST /test_request_number_double_array -func (s *Server) handleTestRequestNumberDoubleArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_array"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberDoubleArray", - ID: "test_request_number_double_array", + Name: "TestRequestIntegerUnixNanoNullable", + ID: "test_request_integer_unix-nano_nullable", } ) - request, close, err := s.decodeTestRequestNumberDoubleArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNanoNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6756,15 +6374,15 @@ func (s *Server) handleTestRequestNumberDoubleArrayRequest(args [0]string, w htt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberDoubleArray", - OperationID: "test_request_number_double_array", + OperationName: "TestRequestIntegerUnixNanoNullable", + OperationID: "test_request_integer_unix-nano_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []float64 + Request = OptNilUnixNano Params = struct{} Response = Error ) @@ -6777,11 +6395,11 @@ func (s *Server) handleTestRequestNumberDoubleArrayRequest(args [0]string, w htt mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberDoubleArray(ctx, request) + return s.h.TestRequestIntegerUnixNanoNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberDoubleArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixNanoNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -6789,23 +6407,23 @@ func (s *Server) handleTestRequestNumberDoubleArrayRequest(args [0]string, w htt return } - if err := encodeTestRequestNumberDoubleArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNanoNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberDoubleArrayArrayRequest handles test_request_number_double_array_array operation. +// HandleTestRequestIntegerUnixNanoNullableArrayRequest handles test_request_integer_unix-nano_nullable_array operation. // -// POST /test_request_number_double_array_array -func (s *Server) handleTestRequestNumberDoubleArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-nano_nullable_array +func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_array_array"), + otelogen.OperationID("test_request_integer_unix-nano_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6829,11 +6447,11 @@ func (s *Server) handleTestRequestNumberDoubleArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberDoubleArrayArray", - ID: "test_request_number_double_array_array", + Name: "TestRequestIntegerUnixNanoNullableArray", + ID: "test_request_integer_unix-nano_nullable_array", } ) - request, close, err := s.decodeTestRequestNumberDoubleArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNanoNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6853,15 +6471,15 @@ func (s *Server) handleTestRequestNumberDoubleArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberDoubleArrayArray", - OperationID: "test_request_number_double_array_array", + OperationName: "TestRequestIntegerUnixNanoNullableArray", + OperationID: "test_request_integer_unix-nano_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]float64 + Request = []NilUnixNano Params = struct{} Response = Error ) @@ -6874,11 +6492,11 @@ func (s *Server) handleTestRequestNumberDoubleArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberDoubleArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixNanoNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberDoubleArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixNanoNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -6886,23 +6504,23 @@ func (s *Server) handleTestRequestNumberDoubleArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestNumberDoubleArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNanoNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberDoubleNullableRequest handles test_request_number_double_nullable operation. +// HandleTestRequestIntegerUnixNanoNullableArrayArrayRequest handles test_request_integer_unix-nano_nullable_array_array operation. // -// POST /test_request_number_double_nullable -func (s *Server) handleTestRequestNumberDoubleNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-nano_nullable_array_array +func (s *Server) handleTestRequestIntegerUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_nullable"), + otelogen.OperationID("test_request_integer_unix-nano_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -6926,11 +6544,11 @@ func (s *Server) handleTestRequestNumberDoubleNullableRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberDoubleNullable", - ID: "test_request_number_double_nullable", + Name: "TestRequestIntegerUnixNanoNullableArrayArray", + ID: "test_request_integer_unix-nano_nullable_array_array", } ) - request, close, err := s.decodeTestRequestNumberDoubleNullableRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -6950,15 +6568,15 @@ func (s *Server) handleTestRequestNumberDoubleNullableRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberDoubleNullable", - OperationID: "test_request_number_double_nullable", + OperationName: "TestRequestIntegerUnixNanoNullableArrayArray", + OperationID: "test_request_integer_unix-nano_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilFloat64 + Request = [][]NilUnixNano Params = struct{} Response = Error ) @@ -6971,11 +6589,11 @@ func (s *Server) handleTestRequestNumberDoubleNullableRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberDoubleNullable(ctx, request) + return s.h.TestRequestIntegerUnixNanoNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberDoubleNullable(ctx, request) + response, err = s.h.TestRequestIntegerUnixNanoNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -6983,23 +6601,23 @@ func (s *Server) handleTestRequestNumberDoubleNullableRequest(args [0]string, w return } - if err := encodeTestRequestNumberDoubleNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberDoubleNullableArrayRequest handles test_request_number_double_nullable_array operation. +// HandleTestRequestIntegerUnixNullableRequest handles test_request_integer_unix_nullable operation. // -// POST /test_request_number_double_nullable_array -func (s *Server) handleTestRequestNumberDoubleNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix_nullable +func (s *Server) handleTestRequestIntegerUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_nullable_array"), + otelogen.OperationID("test_request_integer_unix_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7023,11 +6641,11 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberDoubleNullableArray", - ID: "test_request_number_double_nullable_array", + Name: "TestRequestIntegerUnixNullable", + ID: "test_request_integer_unix_nullable", } ) - request, close, err := s.decodeTestRequestNumberDoubleNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7047,15 +6665,15 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberDoubleNullableArray", - OperationID: "test_request_number_double_nullable_array", + OperationName: "TestRequestIntegerUnixNullable", + OperationID: "test_request_integer_unix_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilFloat64 + Request = OptNilUnixSeconds Params = struct{} Response = Error ) @@ -7068,11 +6686,11 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberDoubleNullableArray(ctx, request) + return s.h.TestRequestIntegerUnixNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberDoubleNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -7080,23 +6698,23 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayRequest(args [0]strin return } - if err := encodeTestRequestNumberDoubleNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberDoubleNullableArrayArrayRequest handles test_request_number_double_nullable_array_array operation. +// HandleTestRequestIntegerUnixNullableArrayRequest handles test_request_integer_unix_nullable_array operation. // -// POST /test_request_number_double_nullable_array_array -func (s *Server) handleTestRequestNumberDoubleNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix_nullable_array +func (s *Server) handleTestRequestIntegerUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_double_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7120,11 +6738,11 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberDoubleNullableArrayArray", - ID: "test_request_number_double_nullable_array_array", + Name: "TestRequestIntegerUnixNullableArray", + ID: "test_request_integer_unix_nullable_array", } ) - request, close, err := s.decodeTestRequestNumberDoubleNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7144,15 +6762,15 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberDoubleNullableArrayArray", - OperationID: "test_request_number_double_nullable_array_array", + OperationName: "TestRequestIntegerUnixNullableArray", + OperationID: "test_request_integer_unix_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilFloat64 + Request = []NilUnixSeconds Params = struct{} Response = Error ) @@ -7165,11 +6783,11 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberDoubleNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberDoubleNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -7177,23 +6795,23 @@ func (s *Server) handleTestRequestNumberDoubleNullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestNumberDoubleNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberFloatRequest handles test_request_number_float operation. +// HandleTestRequestIntegerUnixNullableArrayArrayRequest handles test_request_integer_unix_nullable_array_array operation. // -// POST /test_request_number_float -func (s *Server) handleTestRequestNumberFloatRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix_nullable_array_array +func (s *Server) handleTestRequestIntegerUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float"), + otelogen.OperationID("test_request_integer_unix_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloat", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7217,11 +6835,11 @@ func (s *Server) handleTestRequestNumberFloatRequest(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberFloat", - ID: "test_request_number_float", + Name: "TestRequestIntegerUnixNullableArrayArray", + ID: "test_request_integer_unix_nullable_array_array", } ) - request, close, err := s.decodeTestRequestNumberFloatRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7241,15 +6859,15 @@ func (s *Server) handleTestRequestNumberFloatRequest(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberFloat", - OperationID: "test_request_number_float", + OperationName: "TestRequestIntegerUnixNullableArrayArray", + OperationID: "test_request_integer_unix_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptFloat32 + Request = [][]NilUnixSeconds Params = struct{} Response = Error ) @@ -7262,11 +6880,11 @@ func (s *Server) handleTestRequestNumberFloatRequest(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberFloat(ctx, request) + return s.h.TestRequestIntegerUnixNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberFloat(ctx, request) + response, err = s.h.TestRequestIntegerUnixNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -7274,23 +6892,23 @@ func (s *Server) handleTestRequestNumberFloatRequest(args [0]string, w http.Resp return } - if err := encodeTestRequestNumberFloatResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberFloatArrayRequest handles test_request_number_float_array operation. +// HandleTestRequestIntegerUnixSecondsRequest handles test_request_integer_unix-seconds operation. // -// POST /test_request_number_float_array -func (s *Server) handleTestRequestNumberFloatArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-seconds +func (s *Server) handleTestRequestIntegerUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_array"), + otelogen.OperationID("test_request_integer_unix-seconds"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSeconds", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7314,108 +6932,11 @@ func (s *Server) handleTestRequestNumberFloatArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberFloatArray", - ID: "test_request_number_float_array", - } - ) - request, close, err := s.decodeTestRequestNumberFloatArrayRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestNumberFloatArray", - OperationID: "test_request_number_float_array", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = []float32 - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberFloatArray(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestNumberFloatArray(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestNumberFloatArrayResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestNumberFloatArrayArrayRequest handles test_request_number_float_array_array operation. -// -// POST /test_request_number_float_array_array -func (s *Server) handleTestRequestNumberFloatArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_array_array"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatArrayArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberFloatArrayArray", - ID: "test_request_number_float_array_array", + Name: "TestRequestIntegerUnixSeconds", + ID: "test_request_integer_unix-seconds", } ) - request, close, err := s.decodeTestRequestNumberFloatArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixSecondsRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7435,15 +6956,15 @@ func (s *Server) handleTestRequestNumberFloatArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberFloatArrayArray", - OperationID: "test_request_number_float_array_array", + OperationName: "TestRequestIntegerUnixSeconds", + OperationID: "test_request_integer_unix-seconds", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]float32 + Request = OptUnixSeconds Params = struct{} Response = Error ) @@ -7456,11 +6977,11 @@ func (s *Server) handleTestRequestNumberFloatArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberFloatArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixSeconds(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberFloatArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixSeconds(ctx, request) } if err != nil { recordError("Internal", err) @@ -7468,23 +6989,23 @@ func (s *Server) handleTestRequestNumberFloatArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestNumberFloatArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixSecondsResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberFloatNullableRequest handles test_request_number_float_nullable operation. +// HandleTestRequestIntegerUnixSecondsArrayRequest handles test_request_integer_unix-seconds_array operation. // -// POST /test_request_number_float_nullable -func (s *Server) handleTestRequestNumberFloatNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-seconds_array +func (s *Server) handleTestRequestIntegerUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_nullable"), + otelogen.OperationID("test_request_integer_unix-seconds_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7508,11 +7029,11 @@ func (s *Server) handleTestRequestNumberFloatNullableRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberFloatNullable", - ID: "test_request_number_float_nullable", + Name: "TestRequestIntegerUnixSecondsArray", + ID: "test_request_integer_unix-seconds_array", } ) - request, close, err := s.decodeTestRequestNumberFloatNullableRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixSecondsArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7532,15 +7053,15 @@ func (s *Server) handleTestRequestNumberFloatNullableRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberFloatNullable", - OperationID: "test_request_number_float_nullable", + OperationName: "TestRequestIntegerUnixSecondsArray", + OperationID: "test_request_integer_unix-seconds_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilFloat32 + Request = []time.Time Params = struct{} Response = Error ) @@ -7553,11 +7074,11 @@ func (s *Server) handleTestRequestNumberFloatNullableRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberFloatNullable(ctx, request) + return s.h.TestRequestIntegerUnixSecondsArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberFloatNullable(ctx, request) + response, err = s.h.TestRequestIntegerUnixSecondsArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -7565,23 +7086,23 @@ func (s *Server) handleTestRequestNumberFloatNullableRequest(args [0]string, w h return } - if err := encodeTestRequestNumberFloatNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixSecondsArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberFloatNullableArrayRequest handles test_request_number_float_nullable_array operation. +// HandleTestRequestIntegerUnixSecondsArrayArrayRequest handles test_request_integer_unix-seconds_array_array operation. // -// POST /test_request_number_float_nullable_array -func (s *Server) handleTestRequestNumberFloatNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-seconds_array_array +func (s *Server) handleTestRequestIntegerUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_nullable_array"), + otelogen.OperationID("test_request_integer_unix-seconds_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7605,11 +7126,11 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberFloatNullableArray", - ID: "test_request_number_float_nullable_array", + Name: "TestRequestIntegerUnixSecondsArrayArray", + ID: "test_request_integer_unix-seconds_array_array", } ) - request, close, err := s.decodeTestRequestNumberFloatNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixSecondsArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7629,15 +7150,15 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberFloatNullableArray", - OperationID: "test_request_number_float_nullable_array", + OperationName: "TestRequestIntegerUnixSecondsArrayArray", + OperationID: "test_request_integer_unix-seconds_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilFloat32 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -7650,11 +7171,11 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberFloatNullableArray(ctx, request) + return s.h.TestRequestIntegerUnixSecondsArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberFloatNullableArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixSecondsArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -7662,23 +7183,23 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayRequest(args [0]string return } - if err := encodeTestRequestNumberFloatNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixSecondsArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberFloatNullableArrayArrayRequest handles test_request_number_float_nullable_array_array operation. +// HandleTestRequestIntegerUnixSecondsNullableRequest handles test_request_integer_unix-seconds_nullable operation. // -// POST /test_request_number_float_nullable_array_array -func (s *Server) handleTestRequestNumberFloatNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-seconds_nullable +func (s *Server) handleTestRequestIntegerUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_float_nullable_array_array"), + otelogen.OperationID("test_request_integer_unix-seconds_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7702,11 +7223,11 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberFloatNullableArrayArray", - ID: "test_request_number_float_nullable_array_array", + Name: "TestRequestIntegerUnixSecondsNullable", + ID: "test_request_integer_unix-seconds_nullable", } ) - request, close, err := s.decodeTestRequestNumberFloatNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixSecondsNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7726,15 +7247,15 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberFloatNullableArrayArray", - OperationID: "test_request_number_float_nullable_array_array", + OperationName: "TestRequestIntegerUnixSecondsNullable", + OperationID: "test_request_integer_unix-seconds_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilFloat32 + Request = OptNilUnixSeconds Params = struct{} Response = Error ) @@ -7747,11 +7268,11 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberFloatNullableArrayArray(ctx, request) + return s.h.TestRequestIntegerUnixSecondsNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberFloatNullableArrayArray(ctx, request) + response, err = s.h.TestRequestIntegerUnixSecondsNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -7759,23 +7280,23 @@ func (s *Server) handleTestRequestNumberFloatNullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestNumberFloatNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixSecondsNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt32Request handles test_request_number_int32 operation. +// HandleTestRequestIntegerUnixSecondsNullableArrayRequest handles test_request_integer_unix-seconds_nullable_array operation. // -// POST /test_request_number_int32 -func (s *Server) handleTestRequestNumberInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-seconds_nullable_array +func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32"), + otelogen.OperationID("test_request_integer_unix-seconds_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7799,11 +7320,11 @@ func (s *Server) handleTestRequestNumberInt32Request(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt32", - ID: "test_request_number_int32", + Name: "TestRequestIntegerUnixSecondsNullableArray", + ID: "test_request_integer_unix-seconds_nullable_array", } ) - request, close, err := s.decodeTestRequestNumberInt32Request(r, span) + request, close, err := s.decodeTestRequestIntegerUnixSecondsNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7823,15 +7344,15 @@ func (s *Server) handleTestRequestNumberInt32Request(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt32", - OperationID: "test_request_number_int32", + OperationName: "TestRequestIntegerUnixSecondsNullableArray", + OperationID: "test_request_integer_unix-seconds_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptInt32 + Request = []NilUnixSeconds Params = struct{} Response = Error ) @@ -7844,11 +7365,11 @@ func (s *Server) handleTestRequestNumberInt32Request(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt32(ctx, request) + return s.h.TestRequestIntegerUnixSecondsNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt32(ctx, request) + response, err = s.h.TestRequestIntegerUnixSecondsNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -7856,23 +7377,23 @@ func (s *Server) handleTestRequestNumberInt32Request(args [0]string, w http.Resp return } - if err := encodeTestRequestNumberInt32Response(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixSecondsNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt32ArrayRequest handles test_request_number_int32_array operation. +// HandleTestRequestIntegerUnixSecondsNullableArrayArrayRequest handles test_request_integer_unix-seconds_nullable_array_array operation. // -// POST /test_request_number_int32_array -func (s *Server) handleTestRequestNumberInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_integer_unix-seconds_nullable_array_array +func (s *Server) handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_array"), + otelogen.OperationID("test_request_integer_unix-seconds_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestIntegerUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7896,11 +7417,11 @@ func (s *Server) handleTestRequestNumberInt32ArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt32Array", - ID: "test_request_number_int32_array", + Name: "TestRequestIntegerUnixSecondsNullableArrayArray", + ID: "test_request_integer_unix-seconds_nullable_array_array", } ) - request, close, err := s.decodeTestRequestNumberInt32ArrayRequest(r, span) + request, close, err := s.decodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -7920,15 +7441,15 @@ func (s *Server) handleTestRequestNumberInt32ArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt32Array", - OperationID: "test_request_number_int32_array", + OperationName: "TestRequestIntegerUnixSecondsNullableArrayArray", + OperationID: "test_request_integer_unix-seconds_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int32 + Request = [][]NilUnixSeconds Params = struct{} Response = Error ) @@ -7941,11 +7462,11 @@ func (s *Server) handleTestRequestNumberInt32ArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt32Array(ctx, request) + return s.h.TestRequestIntegerUnixSecondsNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt32Array(ctx, request) + response, err = s.h.TestRequestIntegerUnixSecondsNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -7953,23 +7474,23 @@ func (s *Server) handleTestRequestNumberInt32ArrayRequest(args [0]string, w http return } - if err := encodeTestRequestNumberInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt32ArrayArrayRequest handles test_request_number_int32_array_array operation. +// HandleTestRequestNullRequest handles test_request_null operation. // -// POST /test_request_number_int32_array_array -func (s *Server) handleTestRequestNumberInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_null +func (s *Server) handleTestRequestNullRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_array_array"), + otelogen.OperationID("test_request_null"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNull", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -7993,108 +7514,11 @@ func (s *Server) handleTestRequestNumberInt32ArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt32ArrayArray", - ID: "test_request_number_int32_array_array", - } - ) - request, close, err := s.decodeTestRequestNumberInt32ArrayArrayRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestNumberInt32ArrayArray", - OperationID: "test_request_number_int32_array_array", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = [][]int32 - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt32ArrayArray(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestNumberInt32ArrayArray(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestNumberInt32ArrayArrayResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestNumberInt32NullableRequest handles test_request_number_int32_nullable operation. -// -// POST /test_request_number_int32_nullable -func (s *Server) handleTestRequestNumberInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_nullable"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32Nullable", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt32Nullable", - ID: "test_request_number_int32_nullable", + Name: "TestRequestNull", + ID: "test_request_null", } ) - request, close, err := s.decodeTestRequestNumberInt32NullableRequest(r, span) + request, close, err := s.decodeTestRequestNullRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8114,15 +7538,15 @@ func (s *Server) handleTestRequestNumberInt32NullableRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt32Nullable", - OperationID: "test_request_number_int32_nullable", + OperationName: "TestRequestNull", + OperationID: "test_request_null", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilInt32 + Request = OptNull Params = struct{} Response = Error ) @@ -8135,11 +7559,11 @@ func (s *Server) handleTestRequestNumberInt32NullableRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt32Nullable(ctx, request) + return s.h.TestRequestNull(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt32Nullable(ctx, request) + response, err = s.h.TestRequestNull(ctx, request) } if err != nil { recordError("Internal", err) @@ -8147,23 +7571,23 @@ func (s *Server) handleTestRequestNumberInt32NullableRequest(args [0]string, w h return } - if err := encodeTestRequestNumberInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestNullResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt32NullableArrayRequest handles test_request_number_int32_nullable_array operation. +// HandleTestRequestNullArrayRequest handles test_request_null_array operation. // -// POST /test_request_number_int32_nullable_array -func (s *Server) handleTestRequestNumberInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_null_array +func (s *Server) handleTestRequestNullArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_nullable_array"), + otelogen.OperationID("test_request_null_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8187,11 +7611,11 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt32NullableArray", - ID: "test_request_number_int32_nullable_array", + Name: "TestRequestNullArray", + ID: "test_request_null_array", } ) - request, close, err := s.decodeTestRequestNumberInt32NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestNullArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8211,15 +7635,15 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt32NullableArray", - OperationID: "test_request_number_int32_nullable_array", + OperationName: "TestRequestNullArray", + OperationID: "test_request_null_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilInt32 + Request = []struct{} Params = struct{} Response = Error ) @@ -8232,11 +7656,11 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt32NullableArray(ctx, request) + return s.h.TestRequestNullArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt32NullableArray(ctx, request) + response, err = s.h.TestRequestNullArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -8244,23 +7668,23 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayRequest(args [0]string return } - if err := encodeTestRequestNumberInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNullArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt32NullableArrayArrayRequest handles test_request_number_int32_nullable_array_array operation. +// HandleTestRequestNullArrayArrayRequest handles test_request_null_array_array operation. // -// POST /test_request_number_int32_nullable_array_array -func (s *Server) handleTestRequestNumberInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_null_array_array +func (s *Server) handleTestRequestNullArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int32_nullable_array_array"), + otelogen.OperationID("test_request_null_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8284,11 +7708,11 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt32NullableArrayArray", - ID: "test_request_number_int32_nullable_array_array", + Name: "TestRequestNullArrayArray", + ID: "test_request_null_array_array", } ) - request, close, err := s.decodeTestRequestNumberInt32NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNullArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8308,15 +7732,15 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt32NullableArrayArray", - OperationID: "test_request_number_int32_nullable_array_array", + OperationName: "TestRequestNullArrayArray", + OperationID: "test_request_null_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilInt32 + Request = [][]struct{} Params = struct{} Response = Error ) @@ -8329,11 +7753,11 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt32NullableArrayArray(ctx, request) + return s.h.TestRequestNullArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestNullArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -8341,23 +7765,23 @@ func (s *Server) handleTestRequestNumberInt32NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestNumberInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNullArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt64Request handles test_request_number_int64 operation. +// HandleTestRequestNullNullableRequest handles test_request_null_nullable operation. // -// POST /test_request_number_int64 -func (s *Server) handleTestRequestNumberInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_null_nullable +func (s *Server) handleTestRequestNullNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64"), + otelogen.OperationID("test_request_null_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8381,11 +7805,11 @@ func (s *Server) handleTestRequestNumberInt64Request(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt64", - ID: "test_request_number_int64", + Name: "TestRequestNullNullable", + ID: "test_request_null_nullable", } ) - request, close, err := s.decodeTestRequestNumberInt64Request(r, span) + request, close, err := s.decodeTestRequestNullNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8405,15 +7829,15 @@ func (s *Server) handleTestRequestNumberInt64Request(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt64", - OperationID: "test_request_number_int64", + OperationName: "TestRequestNullNullable", + OperationID: "test_request_null_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptInt64 + Request = OptNull Params = struct{} Response = Error ) @@ -8426,11 +7850,11 @@ func (s *Server) handleTestRequestNumberInt64Request(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt64(ctx, request) + return s.h.TestRequestNullNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt64(ctx, request) + response, err = s.h.TestRequestNullNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -8438,23 +7862,23 @@ func (s *Server) handleTestRequestNumberInt64Request(args [0]string, w http.Resp return } - if err := encodeTestRequestNumberInt64Response(response, w, span); err != nil { + if err := encodeTestRequestNullNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt64ArrayRequest handles test_request_number_int64_array operation. +// HandleTestRequestNullNullableArrayRequest handles test_request_null_nullable_array operation. // -// POST /test_request_number_int64_array -func (s *Server) handleTestRequestNumberInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_null_nullable_array +func (s *Server) handleTestRequestNullNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_array"), + otelogen.OperationID("test_request_null_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8478,11 +7902,11 @@ func (s *Server) handleTestRequestNumberInt64ArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt64Array", - ID: "test_request_number_int64_array", + Name: "TestRequestNullNullableArray", + ID: "test_request_null_nullable_array", } ) - request, close, err := s.decodeTestRequestNumberInt64ArrayRequest(r, span) + request, close, err := s.decodeTestRequestNullNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8502,15 +7926,15 @@ func (s *Server) handleTestRequestNumberInt64ArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt64Array", - OperationID: "test_request_number_int64_array", + OperationName: "TestRequestNullNullableArray", + OperationID: "test_request_null_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int64 + Request = []struct{} Params = struct{} Response = Error ) @@ -8523,11 +7947,11 @@ func (s *Server) handleTestRequestNumberInt64ArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt64Array(ctx, request) + return s.h.TestRequestNullNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt64Array(ctx, request) + response, err = s.h.TestRequestNullNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -8535,23 +7959,23 @@ func (s *Server) handleTestRequestNumberInt64ArrayRequest(args [0]string, w http return } - if err := encodeTestRequestNumberInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNullNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt64ArrayArrayRequest handles test_request_number_int64_array_array operation. +// HandleTestRequestNullNullableArrayArrayRequest handles test_request_null_nullable_array_array operation. // -// POST /test_request_number_int64_array_array -func (s *Server) handleTestRequestNumberInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_null_nullable_array_array +func (s *Server) handleTestRequestNullNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_array_array"), + otelogen.OperationID("test_request_null_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNullNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8575,11 +7999,11 @@ func (s *Server) handleTestRequestNumberInt64ArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt64ArrayArray", - ID: "test_request_number_int64_array_array", + Name: "TestRequestNullNullableArrayArray", + ID: "test_request_null_nullable_array_array", } ) - request, close, err := s.decodeTestRequestNumberInt64ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNullNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8599,15 +8023,15 @@ func (s *Server) handleTestRequestNumberInt64ArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt64ArrayArray", - OperationID: "test_request_number_int64_array_array", + OperationName: "TestRequestNullNullableArrayArray", + OperationID: "test_request_null_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int64 + Request = [][]struct{} Params = struct{} Response = Error ) @@ -8620,11 +8044,11 @@ func (s *Server) handleTestRequestNumberInt64ArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt64ArrayArray(ctx, request) + return s.h.TestRequestNullNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt64ArrayArray(ctx, request) + response, err = s.h.TestRequestNullNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -8632,23 +8056,23 @@ func (s *Server) handleTestRequestNumberInt64ArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestNumberInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNullNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt64NullableRequest handles test_request_number_int64_nullable operation. +// HandleTestRequestNumberRequest handles test_request_number operation. // -// POST /test_request_number_int64_nullable -func (s *Server) handleTestRequestNumberInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number +func (s *Server) handleTestRequestNumberRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_nullable"), + otelogen.OperationID("test_request_number"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumber", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8672,108 +8096,11 @@ func (s *Server) handleTestRequestNumberInt64NullableRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt64Nullable", - ID: "test_request_number_int64_nullable", - } - ) - request, close, err := s.decodeTestRequestNumberInt64NullableRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestNumberInt64Nullable", - OperationID: "test_request_number_int64_nullable", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = OptNilInt64 - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt64Nullable(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestNumberInt64Nullable(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestNumberInt64NullableResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestNumberInt64NullableArrayRequest handles test_request_number_int64_nullable_array operation. -// -// POST /test_request_number_int64_nullable_array -func (s *Server) handleTestRequestNumberInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_nullable_array"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64NullableArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt64NullableArray", - ID: "test_request_number_int64_nullable_array", + Name: "TestRequestNumber", + ID: "test_request_number", } ) - request, close, err := s.decodeTestRequestNumberInt64NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8793,15 +8120,15 @@ func (s *Server) handleTestRequestNumberInt64NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt64NullableArray", - OperationID: "test_request_number_int64_nullable_array", + OperationName: "TestRequestNumber", + OperationID: "test_request_number", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilInt64 + Request = OptFloat64 Params = struct{} Response = Error ) @@ -8814,11 +8141,11 @@ func (s *Server) handleTestRequestNumberInt64NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt64NullableArray(ctx, request) + return s.h.TestRequestNumber(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt64NullableArray(ctx, request) + response, err = s.h.TestRequestNumber(ctx, request) } if err != nil { recordError("Internal", err) @@ -8826,23 +8153,23 @@ func (s *Server) handleTestRequestNumberInt64NullableArrayRequest(args [0]string return } - if err := encodeTestRequestNumberInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberInt64NullableArrayArrayRequest handles test_request_number_int64_nullable_array_array operation. +// HandleTestRequestNumberArrayRequest handles test_request_number_array operation. // -// POST /test_request_number_int64_nullable_array_array -func (s *Server) handleTestRequestNumberInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_array +func (s *Server) handleTestRequestNumberArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_int64_nullable_array_array"), + otelogen.OperationID("test_request_number_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8866,11 +8193,11 @@ func (s *Server) handleTestRequestNumberInt64NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberInt64NullableArrayArray", - ID: "test_request_number_int64_nullable_array_array", + Name: "TestRequestNumberArray", + ID: "test_request_number_array", } ) - request, close, err := s.decodeTestRequestNumberInt64NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8890,15 +8217,15 @@ func (s *Server) handleTestRequestNumberInt64NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberInt64NullableArrayArray", - OperationID: "test_request_number_int64_nullable_array_array", + OperationName: "TestRequestNumberArray", + OperationID: "test_request_number_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilInt64 + Request = []float64 Params = struct{} Response = Error ) @@ -8911,11 +8238,11 @@ func (s *Server) handleTestRequestNumberInt64NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberInt64NullableArrayArray(ctx, request) + return s.h.TestRequestNumberArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberInt64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestNumberArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -8923,23 +8250,23 @@ func (s *Server) handleTestRequestNumberInt64NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestNumberInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberNullableRequest handles test_request_number_nullable operation. +// HandleTestRequestNumberArrayArrayRequest handles test_request_number_array_array operation. // -// POST /test_request_number_nullable -func (s *Server) handleTestRequestNumberNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_array_array +func (s *Server) handleTestRequestNumberArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_nullable"), + otelogen.OperationID("test_request_number_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -8963,11 +8290,11 @@ func (s *Server) handleTestRequestNumberNullableRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberNullable", - ID: "test_request_number_nullable", + Name: "TestRequestNumberArrayArray", + ID: "test_request_number_array_array", } ) - request, close, err := s.decodeTestRequestNumberNullableRequest(r, span) + request, close, err := s.decodeTestRequestNumberArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -8987,15 +8314,15 @@ func (s *Server) handleTestRequestNumberNullableRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberNullable", - OperationID: "test_request_number_nullable", + OperationName: "TestRequestNumberArrayArray", + OperationID: "test_request_number_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilFloat64 + Request = [][]float64 Params = struct{} Response = Error ) @@ -9008,11 +8335,11 @@ func (s *Server) handleTestRequestNumberNullableRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberNullable(ctx, request) + return s.h.TestRequestNumberArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberNullable(ctx, request) + response, err = s.h.TestRequestNumberArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -9020,23 +8347,23 @@ func (s *Server) handleTestRequestNumberNullableRequest(args [0]string, w http.R return } - if err := encodeTestRequestNumberNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberNullableArrayRequest handles test_request_number_nullable_array operation. +// HandleTestRequestNumberDoubleRequest handles test_request_number_double operation. // -// POST /test_request_number_nullable_array -func (s *Server) handleTestRequestNumberNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_double +func (s *Server) handleTestRequestNumberDoubleRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_nullable_array"), + otelogen.OperationID("test_request_number_double"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDouble", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9060,11 +8387,11 @@ func (s *Server) handleTestRequestNumberNullableArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberNullableArray", - ID: "test_request_number_nullable_array", + Name: "TestRequestNumberDouble", + ID: "test_request_number_double", } ) - request, close, err := s.decodeTestRequestNumberNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberDoubleRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9084,15 +8411,15 @@ func (s *Server) handleTestRequestNumberNullableArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberNullableArray", - OperationID: "test_request_number_nullable_array", + OperationName: "TestRequestNumberDouble", + OperationID: "test_request_number_double", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilFloat64 + Request = OptFloat64 Params = struct{} Response = Error ) @@ -9105,11 +8432,11 @@ func (s *Server) handleTestRequestNumberNullableArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberNullableArray(ctx, request) + return s.h.TestRequestNumberDouble(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberNullableArray(ctx, request) + response, err = s.h.TestRequestNumberDouble(ctx, request) } if err != nil { recordError("Internal", err) @@ -9117,23 +8444,23 @@ func (s *Server) handleTestRequestNumberNullableArrayRequest(args [0]string, w h return } - if err := encodeTestRequestNumberNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberDoubleResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestNumberNullableArrayArrayRequest handles test_request_number_nullable_array_array operation. +// HandleTestRequestNumberDoubleArrayRequest handles test_request_number_double_array operation. // -// POST /test_request_number_nullable_array_array -func (s *Server) handleTestRequestNumberNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_double_array +func (s *Server) handleTestRequestNumberDoubleArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_number_nullable_array_array"), + otelogen.OperationID("test_request_number_double_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9157,11 +8484,11 @@ func (s *Server) handleTestRequestNumberNullableArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestNumberNullableArrayArray", - ID: "test_request_number_nullable_array_array", + Name: "TestRequestNumberDoubleArray", + ID: "test_request_number_double_array", } ) - request, close, err := s.decodeTestRequestNumberNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberDoubleArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9181,15 +8508,15 @@ func (s *Server) handleTestRequestNumberNullableArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestNumberNullableArrayArray", - OperationID: "test_request_number_nullable_array_array", + OperationName: "TestRequestNumberDoubleArray", + OperationID: "test_request_number_double_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilFloat64 + Request = []float64 Params = struct{} Response = Error ) @@ -9202,11 +8529,11 @@ func (s *Server) handleTestRequestNumberNullableArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestNumberNullableArrayArray(ctx, request) + return s.h.TestRequestNumberDoubleArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestNumberNullableArrayArray(ctx, request) + response, err = s.h.TestRequestNumberDoubleArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -9214,23 +8541,23 @@ func (s *Server) handleTestRequestNumberNullableArrayArrayRequest(args [0]string return } - if err := encodeTestRequestNumberNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberDoubleArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredAnyRequest handles test_request_required_Any operation. +// HandleTestRequestNumberDoubleArrayArrayRequest handles test_request_number_double_array_array operation. // -// POST /test_request_required_Any -func (s *Server) handleTestRequestRequiredAnyRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_double_array_array +func (s *Server) handleTestRequestNumberDoubleArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_Any"), + otelogen.OperationID("test_request_number_double_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredAny", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9254,11 +8581,11 @@ func (s *Server) handleTestRequestRequiredAnyRequest(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredAny", - ID: "test_request_required_Any", + Name: "TestRequestNumberDoubleArrayArray", + ID: "test_request_number_double_array_array", } ) - request, close, err := s.decodeTestRequestRequiredAnyRequest(r, span) + request, close, err := s.decodeTestRequestNumberDoubleArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9278,15 +8605,15 @@ func (s *Server) handleTestRequestRequiredAnyRequest(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredAny", - OperationID: "test_request_required_Any", + OperationName: "TestRequestNumberDoubleArrayArray", + OperationID: "test_request_number_double_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = jx.Raw + Request = [][]float64 Params = struct{} Response = Error ) @@ -9299,11 +8626,11 @@ func (s *Server) handleTestRequestRequiredAnyRequest(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredAny(ctx, request) + return s.h.TestRequestNumberDoubleArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredAny(ctx, request) + response, err = s.h.TestRequestNumberDoubleArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -9311,23 +8638,23 @@ func (s *Server) handleTestRequestRequiredAnyRequest(args [0]string, w http.Resp return } - if err := encodeTestRequestRequiredAnyResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberDoubleArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredBooleanRequest handles test_request_required_boolean operation. +// HandleTestRequestNumberDoubleNullableRequest handles test_request_number_double_nullable operation. // -// POST /test_request_required_boolean -func (s *Server) handleTestRequestRequiredBooleanRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_double_nullable +func (s *Server) handleTestRequestNumberDoubleNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean"), + otelogen.OperationID("test_request_number_double_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBoolean", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9351,108 +8678,11 @@ func (s *Server) handleTestRequestRequiredBooleanRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredBoolean", - ID: "test_request_required_boolean", - } - ) - request, close, err := s.decodeTestRequestRequiredBooleanRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestRequiredBoolean", - OperationID: "test_request_required_boolean", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = bool - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredBoolean(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestRequiredBoolean(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestRequiredBooleanResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestRequiredBooleanArrayRequest handles test_request_required_boolean_array operation. -// -// POST /test_request_required_boolean_array -func (s *Server) handleTestRequestRequiredBooleanArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_array"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanArray", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredBooleanArray", - ID: "test_request_required_boolean_array", + Name: "TestRequestNumberDoubleNullable", + ID: "test_request_number_double_nullable", } ) - request, close, err := s.decodeTestRequestRequiredBooleanArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberDoubleNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9472,15 +8702,15 @@ func (s *Server) handleTestRequestRequiredBooleanArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredBooleanArray", - OperationID: "test_request_required_boolean_array", + OperationName: "TestRequestNumberDoubleNullable", + OperationID: "test_request_number_double_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []bool + Request = OptNilFloat64 Params = struct{} Response = Error ) @@ -9493,11 +8723,11 @@ func (s *Server) handleTestRequestRequiredBooleanArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredBooleanArray(ctx, request) + return s.h.TestRequestNumberDoubleNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredBooleanArray(ctx, request) + response, err = s.h.TestRequestNumberDoubleNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -9505,23 +8735,23 @@ func (s *Server) handleTestRequestRequiredBooleanArrayRequest(args [0]string, w return } - if err := encodeTestRequestRequiredBooleanArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberDoubleNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredBooleanArrayArrayRequest handles test_request_required_boolean_array_array operation. +// HandleTestRequestNumberDoubleNullableArrayRequest handles test_request_number_double_nullable_array operation. // -// POST /test_request_required_boolean_array_array -func (s *Server) handleTestRequestRequiredBooleanArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_double_nullable_array +func (s *Server) handleTestRequestNumberDoubleNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_array_array"), + otelogen.OperationID("test_request_number_double_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9545,11 +8775,11 @@ func (s *Server) handleTestRequestRequiredBooleanArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredBooleanArrayArray", - ID: "test_request_required_boolean_array_array", + Name: "TestRequestNumberDoubleNullableArray", + ID: "test_request_number_double_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredBooleanArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberDoubleNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9569,15 +8799,15 @@ func (s *Server) handleTestRequestRequiredBooleanArrayArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredBooleanArrayArray", - OperationID: "test_request_required_boolean_array_array", + OperationName: "TestRequestNumberDoubleNullableArray", + OperationID: "test_request_number_double_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]bool + Request = []NilFloat64 Params = struct{} Response = Error ) @@ -9590,11 +8820,11 @@ func (s *Server) handleTestRequestRequiredBooleanArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredBooleanArrayArray(ctx, request) + return s.h.TestRequestNumberDoubleNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredBooleanArrayArray(ctx, request) + response, err = s.h.TestRequestNumberDoubleNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -9602,23 +8832,23 @@ func (s *Server) handleTestRequestRequiredBooleanArrayArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredBooleanArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberDoubleNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredBooleanNullableRequest handles test_request_required_boolean_nullable operation. +// HandleTestRequestNumberDoubleNullableArrayArrayRequest handles test_request_number_double_nullable_array_array operation. // -// POST /test_request_required_boolean_nullable -func (s *Server) handleTestRequestRequiredBooleanNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_double_nullable_array_array +func (s *Server) handleTestRequestNumberDoubleNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_nullable"), + otelogen.OperationID("test_request_number_double_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberDoubleNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9642,11 +8872,11 @@ func (s *Server) handleTestRequestRequiredBooleanNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredBooleanNullable", - ID: "test_request_required_boolean_nullable", + Name: "TestRequestNumberDoubleNullableArrayArray", + ID: "test_request_number_double_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredBooleanNullableRequest(r, span) + request, close, err := s.decodeTestRequestNumberDoubleNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9666,15 +8896,15 @@ func (s *Server) handleTestRequestRequiredBooleanNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredBooleanNullable", - OperationID: "test_request_required_boolean_nullable", + OperationName: "TestRequestNumberDoubleNullableArrayArray", + OperationID: "test_request_number_double_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilBool + Request = [][]NilFloat64 Params = struct{} Response = Error ) @@ -9687,11 +8917,11 @@ func (s *Server) handleTestRequestRequiredBooleanNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredBooleanNullable(ctx, request) + return s.h.TestRequestNumberDoubleNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredBooleanNullable(ctx, request) + response, err = s.h.TestRequestNumberDoubleNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -9699,23 +8929,23 @@ func (s *Server) handleTestRequestRequiredBooleanNullableRequest(args [0]string, return } - if err := encodeTestRequestRequiredBooleanNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberDoubleNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredBooleanNullableArrayRequest handles test_request_required_boolean_nullable_array operation. +// HandleTestRequestNumberFloatRequest handles test_request_number_float operation. // -// POST /test_request_required_boolean_nullable_array -func (s *Server) handleTestRequestRequiredBooleanNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_float +func (s *Server) handleTestRequestNumberFloatRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_nullable_array"), + otelogen.OperationID("test_request_number_float"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloat", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9739,11 +8969,11 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredBooleanNullableArray", - ID: "test_request_required_boolean_nullable_array", + Name: "TestRequestNumberFloat", + ID: "test_request_number_float", } ) - request, close, err := s.decodeTestRequestRequiredBooleanNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberFloatRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9763,15 +8993,15 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredBooleanNullableArray", - OperationID: "test_request_required_boolean_nullable_array", + OperationName: "TestRequestNumberFloat", + OperationID: "test_request_number_float", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilBool + Request = OptFloat32 Params = struct{} Response = Error ) @@ -9784,11 +9014,11 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredBooleanNullableArray(ctx, request) + return s.h.TestRequestNumberFloat(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredBooleanNullableArray(ctx, request) + response, err = s.h.TestRequestNumberFloat(ctx, request) } if err != nil { recordError("Internal", err) @@ -9796,23 +9026,23 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredBooleanNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberFloatResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredBooleanNullableArrayArrayRequest handles test_request_required_boolean_nullable_array_array operation. +// HandleTestRequestNumberFloatArrayRequest handles test_request_number_float_array operation. // -// POST /test_request_required_boolean_nullable_array_array -func (s *Server) handleTestRequestRequiredBooleanNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_float_array +func (s *Server) handleTestRequestNumberFloatArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_boolean_nullable_array_array"), + otelogen.OperationID("test_request_number_float_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9836,11 +9066,11 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredBooleanNullableArrayArray", - ID: "test_request_required_boolean_nullable_array_array", + Name: "TestRequestNumberFloatArray", + ID: "test_request_number_float_array", } ) - request, close, err := s.decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberFloatArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9860,15 +9090,15 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredBooleanNullableArrayArray", - OperationID: "test_request_required_boolean_nullable_array_array", + OperationName: "TestRequestNumberFloatArray", + OperationID: "test_request_number_float_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilBool + Request = []float32 Params = struct{} Response = Error ) @@ -9881,11 +9111,11 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredBooleanNullableArrayArray(ctx, request) + return s.h.TestRequestNumberFloatArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredBooleanNullableArrayArray(ctx, request) + response, err = s.h.TestRequestNumberFloatArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -9893,23 +9123,23 @@ func (s *Server) handleTestRequestRequiredBooleanNullableArrayArrayRequest(args return } - if err := encodeTestRequestRequiredBooleanNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberFloatArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredEmptyStructRequest handles test_request_required_EmptyStruct operation. +// HandleTestRequestNumberFloatArrayArrayRequest handles test_request_number_float_array_array operation. // -// POST /test_request_required_EmptyStruct -func (s *Server) handleTestRequestRequiredEmptyStructRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_float_array_array +func (s *Server) handleTestRequestNumberFloatArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_EmptyStruct"), + otelogen.OperationID("test_request_number_float_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredEmptyStruct", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -9933,11 +9163,11 @@ func (s *Server) handleTestRequestRequiredEmptyStructRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredEmptyStruct", - ID: "test_request_required_EmptyStruct", + Name: "TestRequestNumberFloatArrayArray", + ID: "test_request_number_float_array_array", } ) - request, close, err := s.decodeTestRequestRequiredEmptyStructRequest(r, span) + request, close, err := s.decodeTestRequestNumberFloatArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -9957,15 +9187,15 @@ func (s *Server) handleTestRequestRequiredEmptyStructRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredEmptyStruct", - OperationID: "test_request_required_EmptyStruct", + OperationName: "TestRequestNumberFloatArrayArray", + OperationID: "test_request_number_float_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = TestRequestRequiredEmptyStructReq + Request = [][]float32 Params = struct{} Response = Error ) @@ -9978,11 +9208,11 @@ func (s *Server) handleTestRequestRequiredEmptyStructRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredEmptyStruct(ctx, request) + return s.h.TestRequestNumberFloatArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredEmptyStruct(ctx, request) + response, err = s.h.TestRequestNumberFloatArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -9990,23 +9220,23 @@ func (s *Server) handleTestRequestRequiredEmptyStructRequest(args [0]string, w h return } - if err := encodeTestRequestRequiredEmptyStructResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberFloatArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredFormatTestRequest handles test_request_required_FormatTest operation. +// HandleTestRequestNumberFloatNullableRequest handles test_request_number_float_nullable operation. // -// POST /test_request_required_FormatTest -func (s *Server) handleTestRequestRequiredFormatTestRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_float_nullable +func (s *Server) handleTestRequestNumberFloatNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_FormatTest"), + otelogen.OperationID("test_request_number_float_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredFormatTest", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10030,108 +9260,11 @@ func (s *Server) handleTestRequestRequiredFormatTestRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredFormatTest", - ID: "test_request_required_FormatTest", - } - ) - request, close, err := s.decodeTestRequestRequiredFormatTestRequest(r, span) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() - - var response Error - if m := s.cfg.Middleware; m != nil { - mreq := middleware.Request{ - Context: ctx, - OperationName: "TestRequestRequiredFormatTest", - OperationID: "test_request_required_FormatTest", - Body: request, - Params: map[string]any{}, - Raw: r, - } - - type ( - Request = TestRequestRequiredFormatTestReq - Params = struct{} - Response = Error - ) - response, err = middleware.HookMiddleware[ - Request, - Params, - Response, - ]( - m, - mreq, - nil, - func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredFormatTest(ctx, request) - }, - ) - } else { - response, err = s.h.TestRequestRequiredFormatTest(ctx, request) - } - if err != nil { - recordError("Internal", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - - if err := encodeTestRequestRequiredFormatTestResponse(response, w, span); err != nil { - recordError("EncodeResponse", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } -} - -// HandleTestRequestRequiredIntegerRequest handles test_request_required_integer operation. -// -// POST /test_request_required_integer -func (s *Server) handleTestRequestRequiredIntegerRequest(args [0]string, w http.ResponseWriter, r *http.Request) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer"), - } - - // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredInteger", - trace.WithAttributes(otelAttrs...), - trace.WithSpanKind(trace.SpanKindServer), - ) - defer span.End() - - // Run stopwatch. - startTime := time.Now() - defer func() { - elapsedDuration := time.Since(startTime) - s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) - }() - - // Increment request counter. - s.requests.Add(ctx, 1, otelAttrs...) - - var ( - recordError = func(stage string, err error) { - span.RecordError(err) - span.SetStatus(codes.Error, stage) - s.errors.Add(ctx, 1, otelAttrs...) - } - err error - opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredInteger", - ID: "test_request_required_integer", + Name: "TestRequestNumberFloatNullable", + ID: "test_request_number_float_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerRequest(r, span) + request, close, err := s.decodeTestRequestNumberFloatNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10151,15 +9284,15 @@ func (s *Server) handleTestRequestRequiredIntegerRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredInteger", - OperationID: "test_request_required_integer", + OperationName: "TestRequestNumberFloatNullable", + OperationID: "test_request_number_float_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = int + Request = OptNilFloat32 Params = struct{} Response = Error ) @@ -10172,11 +9305,11 @@ func (s *Server) handleTestRequestRequiredIntegerRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredInteger(ctx, request) + return s.h.TestRequestNumberFloatNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredInteger(ctx, request) + response, err = s.h.TestRequestNumberFloatNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -10184,23 +9317,23 @@ func (s *Server) handleTestRequestRequiredIntegerRequest(args [0]string, w http. return } - if err := encodeTestRequestRequiredIntegerResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberFloatNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerArrayRequest handles test_request_required_integer_array operation. +// HandleTestRequestNumberFloatNullableArrayRequest handles test_request_number_float_nullable_array operation. // -// POST /test_request_required_integer_array -func (s *Server) handleTestRequestRequiredIntegerArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_float_nullable_array +func (s *Server) handleTestRequestNumberFloatNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_array"), + otelogen.OperationID("test_request_number_float_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10224,11 +9357,11 @@ func (s *Server) handleTestRequestRequiredIntegerArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerArray", - ID: "test_request_required_integer_array", + Name: "TestRequestNumberFloatNullableArray", + ID: "test_request_number_float_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberFloatNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10248,15 +9381,15 @@ func (s *Server) handleTestRequestRequiredIntegerArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerArray", - OperationID: "test_request_required_integer_array", + OperationName: "TestRequestNumberFloatNullableArray", + OperationID: "test_request_number_float_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int + Request = []NilFloat32 Params = struct{} Response = Error ) @@ -10269,11 +9402,11 @@ func (s *Server) handleTestRequestRequiredIntegerArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerArray(ctx, request) + return s.h.TestRequestNumberFloatNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerArray(ctx, request) + response, err = s.h.TestRequestNumberFloatNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -10281,23 +9414,23 @@ func (s *Server) handleTestRequestRequiredIntegerArrayRequest(args [0]string, w return } - if err := encodeTestRequestRequiredIntegerArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberFloatNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerArrayArrayRequest handles test_request_required_integer_array_array operation. +// HandleTestRequestNumberFloatNullableArrayArrayRequest handles test_request_number_float_nullable_array_array operation. // -// POST /test_request_required_integer_array_array -func (s *Server) handleTestRequestRequiredIntegerArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_float_nullable_array_array +func (s *Server) handleTestRequestNumberFloatNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_array_array"), + otelogen.OperationID("test_request_number_float_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberFloatNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10321,11 +9454,11 @@ func (s *Server) handleTestRequestRequiredIntegerArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerArrayArray", - ID: "test_request_required_integer_array_array", + Name: "TestRequestNumberFloatNullableArrayArray", + ID: "test_request_number_float_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberFloatNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10345,15 +9478,15 @@ func (s *Server) handleTestRequestRequiredIntegerArrayArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerArrayArray", - OperationID: "test_request_required_integer_array_array", + OperationName: "TestRequestNumberFloatNullableArrayArray", + OperationID: "test_request_number_float_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int + Request = [][]NilFloat32 Params = struct{} Response = Error ) @@ -10366,11 +9499,11 @@ func (s *Server) handleTestRequestRequiredIntegerArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerArrayArray(ctx, request) + return s.h.TestRequestNumberFloatNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerArrayArray(ctx, request) + response, err = s.h.TestRequestNumberFloatNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -10378,23 +9511,23 @@ func (s *Server) handleTestRequestRequiredIntegerArrayArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredIntegerArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberFloatNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt32Request handles test_request_required_integer_int32 operation. +// HandleTestRequestNumberInt32Request handles test_request_number_int32 operation. // -// POST /test_request_required_integer_int32 -func (s *Server) handleTestRequestRequiredIntegerInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int32 +func (s *Server) handleTestRequestNumberInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32"), + otelogen.OperationID("test_request_number_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10418,11 +9551,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32Request(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt32", - ID: "test_request_required_integer_int32", + Name: "TestRequestNumberInt32", + ID: "test_request_number_int32", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt32Request(r, span) + request, close, err := s.decodeTestRequestNumberInt32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10442,15 +9575,15 @@ func (s *Server) handleTestRequestRequiredIntegerInt32Request(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt32", - OperationID: "test_request_required_integer_int32", + OperationName: "TestRequestNumberInt32", + OperationID: "test_request_number_int32", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = int32 + Request = OptInt32 Params = struct{} Response = Error ) @@ -10463,11 +9596,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32Request(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt32(ctx, request) + return s.h.TestRequestNumberInt32(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt32(ctx, request) + response, err = s.h.TestRequestNumberInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -10475,23 +9608,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt32Request(args [0]string, w return } - if err := encodeTestRequestRequiredIntegerInt32Response(response, w, span); err != nil { + if err := encodeTestRequestNumberInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt32ArrayRequest handles test_request_required_integer_int32_array operation. +// HandleTestRequestNumberInt32ArrayRequest handles test_request_number_int32_array operation. // -// POST /test_request_required_integer_int32_array -func (s *Server) handleTestRequestRequiredIntegerInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int32_array +func (s *Server) handleTestRequestNumberInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_array"), + otelogen.OperationID("test_request_number_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10515,11 +9648,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt32Array", - ID: "test_request_required_integer_int32_array", + Name: "TestRequestNumberInt32Array", + ID: "test_request_number_int32_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt32ArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10539,8 +9672,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt32Array", - OperationID: "test_request_required_integer_int32_array", + OperationName: "TestRequestNumberInt32Array", + OperationID: "test_request_number_int32_array", Body: request, Params: map[string]any{}, Raw: r, @@ -10560,11 +9693,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt32Array(ctx, request) + return s.h.TestRequestNumberInt32Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt32Array(ctx, request) + response, err = s.h.TestRequestNumberInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -10572,23 +9705,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredIntegerInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt32ArrayArrayRequest handles test_request_required_integer_int32_array_array operation. +// HandleTestRequestNumberInt32ArrayArrayRequest handles test_request_number_int32_array_array operation. // -// POST /test_request_required_integer_int32_array_array -func (s *Server) handleTestRequestRequiredIntegerInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int32_array_array +func (s *Server) handleTestRequestNumberInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_array_array"), + otelogen.OperationID("test_request_number_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10612,11 +9745,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt32ArrayArray", - ID: "test_request_required_integer_int32_array_array", + Name: "TestRequestNumberInt32ArrayArray", + ID: "test_request_number_int32_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt32ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10636,8 +9769,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt32ArrayArray", - OperationID: "test_request_required_integer_int32_array_array", + OperationName: "TestRequestNumberInt32ArrayArray", + OperationID: "test_request_number_int32_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -10657,11 +9790,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt32ArrayArray(ctx, request) + return s.h.TestRequestNumberInt32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt32ArrayArray(ctx, request) + response, err = s.h.TestRequestNumberInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -10669,23 +9802,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt32ArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredIntegerInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt32NullableRequest handles test_request_required_integer_int32_nullable operation. +// HandleTestRequestNumberInt32NullableRequest handles test_request_number_int32_nullable operation. // -// POST /test_request_required_integer_int32_nullable -func (s *Server) handleTestRequestRequiredIntegerInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int32_nullable +func (s *Server) handleTestRequestNumberInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_nullable"), + otelogen.OperationID("test_request_number_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10709,11 +9842,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt32Nullable", - ID: "test_request_required_integer_int32_nullable", + Name: "TestRequestNumberInt32Nullable", + ID: "test_request_number_int32_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt32NullableRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10733,15 +9866,15 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt32Nullable", - OperationID: "test_request_required_integer_int32_nullable", + OperationName: "TestRequestNumberInt32Nullable", + OperationID: "test_request_number_int32_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilInt32 + Request = OptNilInt32 Params = struct{} Response = Error ) @@ -10754,11 +9887,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt32Nullable(ctx, request) + return s.h.TestRequestNumberInt32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt32Nullable(ctx, request) + response, err = s.h.TestRequestNumberInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -10766,23 +9899,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableRequest(args [0]st return } - if err := encodeTestRequestRequiredIntegerInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt32NullableArrayRequest handles test_request_required_integer_int32_nullable_array operation. +// HandleTestRequestNumberInt32NullableArrayRequest handles test_request_number_int32_nullable_array operation. // -// POST /test_request_required_integer_int32_nullable_array -func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int32_nullable_array +func (s *Server) handleTestRequestNumberInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_nullable_array"), + otelogen.OperationID("test_request_number_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10806,11 +9939,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt32NullableArray", - ID: "test_request_required_integer_int32_nullable_array", + Name: "TestRequestNumberInt32NullableArray", + ID: "test_request_number_int32_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt32NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10830,8 +9963,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt32NullableArray", - OperationID: "test_request_required_integer_int32_nullable_array", + OperationName: "TestRequestNumberInt32NullableArray", + OperationID: "test_request_number_int32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -10851,11 +9984,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt32NullableArray(ctx, request) + return s.h.TestRequestNumberInt32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt32NullableArray(ctx, request) + response, err = s.h.TestRequestNumberInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -10863,23 +9996,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayRequest(args return } - if err := encodeTestRequestRequiredIntegerInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt32NullableArrayArrayRequest handles test_request_required_integer_int32_nullable_array_array operation. +// HandleTestRequestNumberInt32NullableArrayArrayRequest handles test_request_number_int32_nullable_array_array operation. // -// POST /test_request_required_integer_int32_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int32_nullable_array_array +func (s *Server) handleTestRequestNumberInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int32_nullable_array_array"), + otelogen.OperationID("test_request_number_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -10903,11 +10036,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt32NullableArrayArray", - ID: "test_request_required_integer_int32_nullable_array_array", + Name: "TestRequestNumberInt32NullableArrayArray", + ID: "test_request_number_int32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -10927,8 +10060,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt32NullableArrayArray", - OperationID: "test_request_required_integer_int32_nullable_array_array", + OperationName: "TestRequestNumberInt32NullableArrayArray", + OperationID: "test_request_number_int32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -10948,11 +10081,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt32NullableArrayArray(ctx, request) + return s.h.TestRequestNumberInt32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestNumberInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -10960,23 +10093,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest( return } - if err := encodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt64Request handles test_request_required_integer_int64 operation. +// HandleTestRequestNumberInt64Request handles test_request_number_int64 operation. // -// POST /test_request_required_integer_int64 -func (s *Server) handleTestRequestRequiredIntegerInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int64 +func (s *Server) handleTestRequestNumberInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64"), + otelogen.OperationID("test_request_number_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11000,11 +10133,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64Request(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt64", - ID: "test_request_required_integer_int64", + Name: "TestRequestNumberInt64", + ID: "test_request_number_int64", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt64Request(r, span) + request, close, err := s.decodeTestRequestNumberInt64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11024,15 +10157,15 @@ func (s *Server) handleTestRequestRequiredIntegerInt64Request(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt64", - OperationID: "test_request_required_integer_int64", + OperationName: "TestRequestNumberInt64", + OperationID: "test_request_number_int64", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = int64 + Request = OptInt64 Params = struct{} Response = Error ) @@ -11045,11 +10178,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64Request(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt64(ctx, request) + return s.h.TestRequestNumberInt64(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt64(ctx, request) + response, err = s.h.TestRequestNumberInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -11057,23 +10190,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt64Request(args [0]string, w return } - if err := encodeTestRequestRequiredIntegerInt64Response(response, w, span); err != nil { + if err := encodeTestRequestNumberInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt64ArrayRequest handles test_request_required_integer_int64_array operation. +// HandleTestRequestNumberInt64ArrayRequest handles test_request_number_int64_array operation. // -// POST /test_request_required_integer_int64_array -func (s *Server) handleTestRequestRequiredIntegerInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int64_array +func (s *Server) handleTestRequestNumberInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_array"), + otelogen.OperationID("test_request_number_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11097,11 +10230,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt64Array", - ID: "test_request_required_integer_int64_array", + Name: "TestRequestNumberInt64Array", + ID: "test_request_number_int64_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt64ArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11121,8 +10254,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt64Array", - OperationID: "test_request_required_integer_int64_array", + OperationName: "TestRequestNumberInt64Array", + OperationID: "test_request_number_int64_array", Body: request, Params: map[string]any{}, Raw: r, @@ -11142,11 +10275,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt64Array(ctx, request) + return s.h.TestRequestNumberInt64Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt64Array(ctx, request) + response, err = s.h.TestRequestNumberInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -11154,23 +10287,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredIntegerInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt64ArrayArrayRequest handles test_request_required_integer_int64_array_array operation. +// HandleTestRequestNumberInt64ArrayArrayRequest handles test_request_number_int64_array_array operation. // -// POST /test_request_required_integer_int64_array_array -func (s *Server) handleTestRequestRequiredIntegerInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int64_array_array +func (s *Server) handleTestRequestNumberInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_array_array"), + otelogen.OperationID("test_request_number_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11194,11 +10327,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt64ArrayArray", - ID: "test_request_required_integer_int64_array_array", + Name: "TestRequestNumberInt64ArrayArray", + ID: "test_request_number_int64_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt64ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11218,8 +10351,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt64ArrayArray", - OperationID: "test_request_required_integer_int64_array_array", + OperationName: "TestRequestNumberInt64ArrayArray", + OperationID: "test_request_number_int64_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -11239,11 +10372,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt64ArrayArray(ctx, request) + return s.h.TestRequestNumberInt64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt64ArrayArray(ctx, request) + response, err = s.h.TestRequestNumberInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -11251,23 +10384,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt64ArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredIntegerInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt64NullableRequest handles test_request_required_integer_int64_nullable operation. +// HandleTestRequestNumberInt64NullableRequest handles test_request_number_int64_nullable operation. // -// POST /test_request_required_integer_int64_nullable -func (s *Server) handleTestRequestRequiredIntegerInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int64_nullable +func (s *Server) handleTestRequestNumberInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_nullable"), + otelogen.OperationID("test_request_number_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11291,11 +10424,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt64Nullable", - ID: "test_request_required_integer_int64_nullable", + Name: "TestRequestNumberInt64Nullable", + ID: "test_request_number_int64_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt64NullableRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11315,15 +10448,15 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt64Nullable", - OperationID: "test_request_required_integer_int64_nullable", + OperationName: "TestRequestNumberInt64Nullable", + OperationID: "test_request_number_int64_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilInt64 + Request = OptNilInt64 Params = struct{} Response = Error ) @@ -11336,11 +10469,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt64Nullable(ctx, request) + return s.h.TestRequestNumberInt64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt64Nullable(ctx, request) + response, err = s.h.TestRequestNumberInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -11348,23 +10481,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableRequest(args [0]st return } - if err := encodeTestRequestRequiredIntegerInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt64NullableArrayRequest handles test_request_required_integer_int64_nullable_array operation. +// HandleTestRequestNumberInt64NullableArrayRequest handles test_request_number_int64_nullable_array operation. // -// POST /test_request_required_integer_int64_nullable_array -func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int64_nullable_array +func (s *Server) handleTestRequestNumberInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_nullable_array"), + otelogen.OperationID("test_request_number_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11388,11 +10521,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt64NullableArray", - ID: "test_request_required_integer_int64_nullable_array", + Name: "TestRequestNumberInt64NullableArray", + ID: "test_request_number_int64_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt64NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11412,8 +10545,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt64NullableArray", - OperationID: "test_request_required_integer_int64_nullable_array", + OperationName: "TestRequestNumberInt64NullableArray", + OperationID: "test_request_number_int64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -11433,11 +10566,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt64NullableArray(ctx, request) + return s.h.TestRequestNumberInt64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt64NullableArray(ctx, request) + response, err = s.h.TestRequestNumberInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -11445,23 +10578,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayRequest(args return } - if err := encodeTestRequestRequiredIntegerInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerInt64NullableArrayArrayRequest handles test_request_required_integer_int64_nullable_array_array operation. +// HandleTestRequestNumberInt64NullableArrayArrayRequest handles test_request_number_int64_nullable_array_array operation. // -// POST /test_request_required_integer_int64_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_int64_nullable_array_array +func (s *Server) handleTestRequestNumberInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_int64_nullable_array_array"), + otelogen.OperationID("test_request_number_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11485,11 +10618,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerInt64NullableArrayArray", - ID: "test_request_required_integer_int64_nullable_array_array", + Name: "TestRequestNumberInt64NullableArrayArray", + ID: "test_request_number_int64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberInt64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11509,8 +10642,8 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerInt64NullableArrayArray", - OperationID: "test_request_required_integer_int64_nullable_array_array", + OperationName: "TestRequestNumberInt64NullableArrayArray", + OperationID: "test_request_number_int64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -11530,11 +10663,11 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerInt64NullableArrayArray(ctx, request) + return s.h.TestRequestNumberInt64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerInt64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestNumberInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -11542,23 +10675,23 @@ func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest( return } - if err := encodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerNullableRequest handles test_request_required_integer_nullable operation. +// HandleTestRequestNumberNullableRequest handles test_request_number_nullable operation. // -// POST /test_request_required_integer_nullable -func (s *Server) handleTestRequestRequiredIntegerNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_nullable +func (s *Server) handleTestRequestNumberNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_nullable"), + otelogen.OperationID("test_request_number_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11582,11 +10715,11 @@ func (s *Server) handleTestRequestRequiredIntegerNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerNullable", - ID: "test_request_required_integer_nullable", + Name: "TestRequestNumberNullable", + ID: "test_request_number_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerNullableRequest(r, span) + request, close, err := s.decodeTestRequestNumberNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11606,15 +10739,15 @@ func (s *Server) handleTestRequestRequiredIntegerNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerNullable", - OperationID: "test_request_required_integer_nullable", + OperationName: "TestRequestNumberNullable", + OperationID: "test_request_number_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilInt + Request = OptNilFloat64 Params = struct{} Response = Error ) @@ -11627,11 +10760,11 @@ func (s *Server) handleTestRequestRequiredIntegerNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerNullable(ctx, request) + return s.h.TestRequestNumberNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerNullable(ctx, request) + response, err = s.h.TestRequestNumberNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -11639,23 +10772,23 @@ func (s *Server) handleTestRequestRequiredIntegerNullableRequest(args [0]string, return } - if err := encodeTestRequestRequiredIntegerNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerNullableArrayRequest handles test_request_required_integer_nullable_array operation. +// HandleTestRequestNumberNullableArrayRequest handles test_request_number_nullable_array operation. // -// POST /test_request_required_integer_nullable_array -func (s *Server) handleTestRequestRequiredIntegerNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_nullable_array +func (s *Server) handleTestRequestNumberNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_nullable_array"), + otelogen.OperationID("test_request_number_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11679,11 +10812,11 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerNullableArray", - ID: "test_request_required_integer_nullable_array", + Name: "TestRequestNumberNullableArray", + ID: "test_request_number_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11703,15 +10836,15 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerNullableArray", - OperationID: "test_request_required_integer_nullable_array", + OperationName: "TestRequestNumberNullableArray", + OperationID: "test_request_number_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilInt + Request = []NilFloat64 Params = struct{} Response = Error ) @@ -11724,11 +10857,11 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerNullableArray(ctx, request) + return s.h.TestRequestNumberNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerNullableArray(ctx, request) + response, err = s.h.TestRequestNumberNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -11736,23 +10869,23 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredIntegerNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerNullableArrayArrayRequest handles test_request_required_integer_nullable_array_array operation. +// HandleTestRequestNumberNullableArrayArrayRequest handles test_request_number_nullable_array_array operation. // -// POST /test_request_required_integer_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_number_nullable_array_array +func (s *Server) handleTestRequestNumberNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_nullable_array_array"), + otelogen.OperationID("test_request_number_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestNumberNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11776,11 +10909,11 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerNullableArrayArray", - ID: "test_request_required_integer_nullable_array_array", + Name: "TestRequestNumberNullableArrayArray", + ID: "test_request_number_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestNumberNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11800,15 +10933,15 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerNullableArrayArray", - OperationID: "test_request_required_integer_nullable_array_array", + OperationName: "TestRequestNumberNullableArrayArray", + OperationID: "test_request_number_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilInt + Request = [][]NilFloat64 Params = struct{} Response = Error ) @@ -11821,11 +10954,11 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerNullableArrayArray(ctx, request) + return s.h.TestRequestNumberNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerNullableArrayArray(ctx, request) + response, err = s.h.TestRequestNumberNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -11833,23 +10966,23 @@ func (s *Server) handleTestRequestRequiredIntegerNullableArrayArrayRequest(args return } - if err := encodeTestRequestRequiredIntegerNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestNumberNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixRequest handles test_request_required_integer_unix operation. +// HandleTestRequestRequiredAnyRequest handles test_request_required_Any operation. // -// POST /test_request_required_integer_unix -func (s *Server) handleTestRequestRequiredIntegerUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_Any +func (s *Server) handleTestRequestRequiredAnyRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix"), + otelogen.OperationID("test_request_required_Any"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnix", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredAny", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11873,11 +11006,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnix", - ID: "test_request_required_integer_unix", + Name: "TestRequestRequiredAny", + ID: "test_request_required_Any", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixRequest(r, span) + request, close, err := s.decodeTestRequestRequiredAnyRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11897,15 +11030,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnix", - OperationID: "test_request_required_integer_unix", + OperationName: "TestRequestRequiredAny", + OperationID: "test_request_required_Any", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = jx.Raw Params = struct{} Response = Error ) @@ -11918,11 +11051,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnix(ctx, request) + return s.h.TestRequestRequiredAny(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnix(ctx, request) + response, err = s.h.TestRequestRequiredAny(ctx, request) } if err != nil { recordError("Internal", err) @@ -11930,23 +11063,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixRequest(args [0]string, w h return } - if err := encodeTestRequestRequiredIntegerUnixResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredAnyResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixArrayRequest handles test_request_required_integer_unix_array operation. +// HandleTestRequestRequiredBooleanRequest handles test_request_required_boolean operation. // -// POST /test_request_required_integer_unix_array -func (s *Server) handleTestRequestRequiredIntegerUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_boolean +func (s *Server) handleTestRequestRequiredBooleanRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_array"), + otelogen.OperationID("test_request_required_boolean"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBoolean", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -11970,11 +11103,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixArray", - ID: "test_request_required_integer_unix_array", + Name: "TestRequestRequiredBoolean", + ID: "test_request_required_boolean", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredBooleanRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -11994,15 +11127,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixArray", - OperationID: "test_request_required_integer_unix_array", + OperationName: "TestRequestRequiredBoolean", + OperationID: "test_request_required_boolean", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = bool Params = struct{} Response = Error ) @@ -12015,11 +11148,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixArray(ctx, request) + return s.h.TestRequestRequiredBoolean(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixArray(ctx, request) + response, err = s.h.TestRequestRequiredBoolean(ctx, request) } if err != nil { recordError("Internal", err) @@ -12027,23 +11160,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredIntegerUnixArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredBooleanResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixArrayArrayRequest handles test_request_required_integer_unix_array_array operation. +// HandleTestRequestRequiredBooleanArrayRequest handles test_request_required_boolean_array operation. // -// POST /test_request_required_integer_unix_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_boolean_array +func (s *Server) handleTestRequestRequiredBooleanArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_array_array"), + otelogen.OperationID("test_request_required_boolean_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12067,11 +11200,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixArrayArray", - ID: "test_request_required_integer_unix_array_array", + Name: "TestRequestRequiredBooleanArray", + ID: "test_request_required_boolean_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredBooleanArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12091,15 +11224,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixArrayArray", - OperationID: "test_request_required_integer_unix_array_array", + OperationName: "TestRequestRequiredBooleanArray", + OperationID: "test_request_required_boolean_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = []bool Params = struct{} Response = Error ) @@ -12112,11 +11245,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixArrayArray(ctx, request) + return s.h.TestRequestRequiredBooleanArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredBooleanArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -12124,23 +11257,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredIntegerUnixArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredBooleanArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMicroRequest handles test_request_required_integer_unix-micro operation. +// HandleTestRequestRequiredBooleanArrayArrayRequest handles test_request_required_boolean_array_array operation. // -// POST /test_request_required_integer_unix-micro -func (s *Server) handleTestRequestRequiredIntegerUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_boolean_array_array +func (s *Server) handleTestRequestRequiredBooleanArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro"), + otelogen.OperationID("test_request_required_boolean_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicro", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12164,11 +11297,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMicro", - ID: "test_request_required_integer_unix-micro", + Name: "TestRequestRequiredBooleanArrayArray", + ID: "test_request_required_boolean_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroRequest(r, span) + request, close, err := s.decodeTestRequestRequiredBooleanArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12188,15 +11321,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMicro", - OperationID: "test_request_required_integer_unix-micro", + OperationName: "TestRequestRequiredBooleanArrayArray", + OperationID: "test_request_required_boolean_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = [][]bool Params = struct{} Response = Error ) @@ -12209,11 +11342,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMicro(ctx, request) + return s.h.TestRequestRequiredBooleanArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMicro(ctx, request) + response, err = s.h.TestRequestRequiredBooleanArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -12221,23 +11354,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroRequest(args [0]string return } - if err := encodeTestRequestRequiredIntegerUnixMicroResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredBooleanArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMicroArrayRequest handles test_request_required_integer_unix-micro_array operation. +// HandleTestRequestRequiredBooleanNullableRequest handles test_request_required_boolean_nullable operation. // -// POST /test_request_required_integer_unix-micro_array -func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_boolean_nullable +func (s *Server) handleTestRequestRequiredBooleanNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_array"), + otelogen.OperationID("test_request_required_boolean_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12261,11 +11394,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMicroArray", - ID: "test_request_required_integer_unix-micro_array", + Name: "TestRequestRequiredBooleanNullable", + ID: "test_request_required_boolean_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredBooleanNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12285,15 +11418,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMicroArray", - OperationID: "test_request_required_integer_unix-micro_array", + OperationName: "TestRequestRequiredBooleanNullable", + OperationID: "test_request_required_boolean_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = NilBool Params = struct{} Response = Error ) @@ -12306,11 +11439,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMicroArray(ctx, request) + return s.h.TestRequestRequiredBooleanNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMicroArray(ctx, request) + response, err = s.h.TestRequestRequiredBooleanNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -12318,23 +11451,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredIntegerUnixMicroArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredBooleanNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMicroArrayArrayRequest handles test_request_required_integer_unix-micro_array_array operation. +// HandleTestRequestRequiredBooleanNullableArrayRequest handles test_request_required_boolean_nullable_array operation. // -// POST /test_request_required_integer_unix-micro_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_boolean_nullable_array +func (s *Server) handleTestRequestRequiredBooleanNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_array_array"), + otelogen.OperationID("test_request_required_boolean_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12358,11 +11491,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMicroArrayArray", - ID: "test_request_required_integer_unix-micro_array_array", + Name: "TestRequestRequiredBooleanNullableArray", + ID: "test_request_required_boolean_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredBooleanNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12382,15 +11515,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMicroArrayArray", - OperationID: "test_request_required_integer_unix-micro_array_array", + OperationName: "TestRequestRequiredBooleanNullableArray", + OperationID: "test_request_required_boolean_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = []NilBool Params = struct{} Response = Error ) @@ -12403,11 +11536,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMicroArrayArray(ctx, request) + return s.h.TestRequestRequiredBooleanNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredBooleanNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -12415,23 +11548,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest(args return } - if err := encodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredBooleanNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMicroNullableRequest handles test_request_required_integer_unix-micro_nullable operation. +// HandleTestRequestRequiredBooleanNullableArrayArrayRequest handles test_request_required_boolean_nullable_array_array operation. // -// POST /test_request_required_integer_unix-micro_nullable -func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_boolean_nullable_array_array +func (s *Server) handleTestRequestRequiredBooleanNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_nullable"), + otelogen.OperationID("test_request_required_boolean_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredBooleanNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12455,11 +11588,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMicroNullable", - ID: "test_request_required_integer_unix-micro_nullable", + Name: "TestRequestRequiredBooleanNullableArrayArray", + ID: "test_request_required_boolean_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12479,15 +11612,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMicroNullable", - OperationID: "test_request_required_integer_unix-micro_nullable", + OperationName: "TestRequestRequiredBooleanNullableArrayArray", + OperationID: "test_request_required_boolean_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilUnixMicro + Request = [][]NilBool Params = struct{} Response = Error ) @@ -12500,11 +11633,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMicroNullable(ctx, request) + return s.h.TestRequestRequiredBooleanNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestRequiredBooleanNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -12512,23 +11645,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableRequest(args [ return } - if err := encodeTestRequestRequiredIntegerUnixMicroNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredBooleanNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMicroNullableArrayRequest handles test_request_required_integer_unix-micro_nullable_array operation. +// HandleTestRequestRequiredEmptyStructRequest handles test_request_required_EmptyStruct operation. // -// POST /test_request_required_integer_unix-micro_nullable_array -func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_EmptyStruct +func (s *Server) handleTestRequestRequiredEmptyStructRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array"), + otelogen.OperationID("test_request_required_EmptyStruct"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredEmptyStruct", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12552,11 +11685,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMicroNullableArray", - ID: "test_request_required_integer_unix-micro_nullable_array", + Name: "TestRequestRequiredEmptyStruct", + ID: "test_request_required_EmptyStruct", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredEmptyStructRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12576,15 +11709,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMicroNullableArray", - OperationID: "test_request_required_integer_unix-micro_nullable_array", + OperationName: "TestRequestRequiredEmptyStruct", + OperationID: "test_request_required_EmptyStruct", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixMicro + Request = TestRequestRequiredEmptyStructReq Params = struct{} Response = Error ) @@ -12597,11 +11730,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMicroNullableArray(ctx, request) + return s.h.TestRequestRequiredEmptyStruct(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredEmptyStruct(ctx, request) } if err != nil { recordError("Internal", err) @@ -12609,23 +11742,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest(a return } - if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredEmptyStructResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest handles test_request_required_integer_unix-micro_nullable_array_array operation. +// HandleTestRequestRequiredFormatTestRequest handles test_request_required_FormatTest operation. // -// POST /test_request_required_integer_unix-micro_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_FormatTest +func (s *Server) handleTestRequestRequiredFormatTestRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_required_FormatTest"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredFormatTest", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12649,11 +11782,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMicroNullableArrayArray", - ID: "test_request_required_integer_unix-micro_nullable_array_array", + Name: "TestRequestRequiredFormatTest", + ID: "test_request_required_FormatTest", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredFormatTestRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12673,15 +11806,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMicroNullableArrayArray", - OperationID: "test_request_required_integer_unix-micro_nullable_array_array", + OperationName: "TestRequestRequiredFormatTest", + OperationID: "test_request_required_FormatTest", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixMicro + Request = TestRequestRequiredFormatTestReq Params = struct{} Response = Error ) @@ -12694,11 +11827,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredFormatTest(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredFormatTest(ctx, request) } if err != nil { recordError("Internal", err) @@ -12706,23 +11839,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequ return } - if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredFormatTestResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMilliRequest handles test_request_required_integer_unix-milli operation. +// HandleTestRequestRequiredIntegerRequest handles test_request_required_integer operation. // -// POST /test_request_required_integer_unix-milli -func (s *Server) handleTestRequestRequiredIntegerUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer +func (s *Server) handleTestRequestRequiredIntegerRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli"), + otelogen.OperationID("test_request_required_integer"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilli", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredInteger", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12746,11 +11879,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMilli", - ID: "test_request_required_integer_unix-milli", + Name: "TestRequestRequiredInteger", + ID: "test_request_required_integer", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12770,15 +11903,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMilli", - OperationID: "test_request_required_integer_unix-milli", + OperationName: "TestRequestRequiredInteger", + OperationID: "test_request_required_integer", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = int Params = struct{} Response = Error ) @@ -12791,11 +11924,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMilli(ctx, request) + return s.h.TestRequestRequiredInteger(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMilli(ctx, request) + response, err = s.h.TestRequestRequiredInteger(ctx, request) } if err != nil { recordError("Internal", err) @@ -12803,23 +11936,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliRequest(args [0]string return } - if err := encodeTestRequestRequiredIntegerUnixMilliResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMilliArrayRequest handles test_request_required_integer_unix-milli_array operation. +// HandleTestRequestRequiredIntegerArrayRequest handles test_request_required_integer_array operation. // -// POST /test_request_required_integer_unix-milli_array -func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_array +func (s *Server) handleTestRequestRequiredIntegerArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_array"), + otelogen.OperationID("test_request_required_integer_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12843,11 +11976,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMilliArray", - ID: "test_request_required_integer_unix-milli_array", + Name: "TestRequestRequiredIntegerArray", + ID: "test_request_required_integer_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12867,15 +12000,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMilliArray", - OperationID: "test_request_required_integer_unix-milli_array", + OperationName: "TestRequestRequiredIntegerArray", + OperationID: "test_request_required_integer_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []int Params = struct{} Response = Error ) @@ -12888,11 +12021,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMilliArray(ctx, request) + return s.h.TestRequestRequiredIntegerArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMilliArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -12900,23 +12033,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredIntegerUnixMilliArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMilliArrayArrayRequest handles test_request_required_integer_unix-milli_array_array operation. +// HandleTestRequestRequiredIntegerArrayArrayRequest handles test_request_required_integer_array_array operation. // -// POST /test_request_required_integer_unix-milli_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_array_array +func (s *Server) handleTestRequestRequiredIntegerArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_array_array"), + otelogen.OperationID("test_request_required_integer_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -12940,11 +12073,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMilliArrayArray", - ID: "test_request_required_integer_unix-milli_array_array", + Name: "TestRequestRequiredIntegerArrayArray", + ID: "test_request_required_integer_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -12964,15 +12097,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMilliArrayArray", - OperationID: "test_request_required_integer_unix-milli_array_array", + OperationName: "TestRequestRequiredIntegerArrayArray", + OperationID: "test_request_required_integer_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]int Params = struct{} Response = Error ) @@ -12985,11 +12118,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMilliArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -12997,23 +12130,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest(args return } - if err := encodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMilliNullableRequest handles test_request_required_integer_unix-milli_nullable operation. +// HandleTestRequestRequiredIntegerInt32Request handles test_request_required_integer_int32 operation. // -// POST /test_request_required_integer_unix-milli_nullable -func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int32 +func (s *Server) handleTestRequestRequiredIntegerInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_nullable"), + otelogen.OperationID("test_request_required_integer_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13037,11 +12170,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMilliNullable", - ID: "test_request_required_integer_unix-milli_nullable", + Name: "TestRequestRequiredIntegerInt32", + ID: "test_request_required_integer_int32", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13061,15 +12194,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMilliNullable", - OperationID: "test_request_required_integer_unix-milli_nullable", + OperationName: "TestRequestRequiredIntegerInt32", + OperationID: "test_request_required_integer_int32", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilUnixMilli + Request = int32 Params = struct{} Response = Error ) @@ -13082,11 +12215,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMilliNullable(ctx, request) + return s.h.TestRequestRequiredIntegerInt32(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -13094,23 +12227,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableRequest(args [ return } - if err := encodeTestRequestRequiredIntegerUnixMilliNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMilliNullableArrayRequest handles test_request_required_integer_unix-milli_nullable_array operation. +// HandleTestRequestRequiredIntegerInt32ArrayRequest handles test_request_required_integer_int32_array operation. // -// POST /test_request_required_integer_unix-milli_nullable_array -func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int32_array +func (s *Server) handleTestRequestRequiredIntegerInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array"), + otelogen.OperationID("test_request_required_integer_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13134,11 +12267,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMilliNullableArray", - ID: "test_request_required_integer_unix-milli_nullable_array", + Name: "TestRequestRequiredIntegerInt32Array", + ID: "test_request_required_integer_int32_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13158,15 +12291,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMilliNullableArray", - OperationID: "test_request_required_integer_unix-milli_nullable_array", + OperationName: "TestRequestRequiredIntegerInt32Array", + OperationID: "test_request_required_integer_int32_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixMilli + Request = []int32 Params = struct{} Response = Error ) @@ -13179,11 +12312,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMilliNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt32Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -13191,23 +12324,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest(a return } - if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest handles test_request_required_integer_unix-milli_nullable_array_array operation. +// HandleTestRequestRequiredIntegerInt32ArrayArrayRequest handles test_request_required_integer_int32_array_array operation. // -// POST /test_request_required_integer_unix-milli_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int32_array_array +func (s *Server) handleTestRequestRequiredIntegerInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13231,11 +12364,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixMilliNullableArrayArray", - ID: "test_request_required_integer_unix-milli_nullable_array_array", + Name: "TestRequestRequiredIntegerInt32ArrayArray", + ID: "test_request_required_integer_int32_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13255,15 +12388,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixMilliNullableArrayArray", - OperationID: "test_request_required_integer_unix-milli_nullable_array_array", + OperationName: "TestRequestRequiredIntegerInt32ArrayArray", + OperationID: "test_request_required_integer_int32_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixMilli + Request = [][]int32 Params = struct{} Response = Error ) @@ -13276,11 +12409,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -13288,23 +12421,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequ return } - if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNanoRequest handles test_request_required_integer_unix-nano operation. +// HandleTestRequestRequiredIntegerInt32NullableRequest handles test_request_required_integer_int32_nullable operation. // -// POST /test_request_required_integer_unix-nano -func (s *Server) handleTestRequestRequiredIntegerUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int32_nullable +func (s *Server) handleTestRequestRequiredIntegerInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano"), + otelogen.OperationID("test_request_required_integer_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNano", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13328,11 +12461,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNano", - ID: "test_request_required_integer_unix-nano", + Name: "TestRequestRequiredIntegerInt32Nullable", + ID: "test_request_required_integer_int32_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13352,15 +12485,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNano", - OperationID: "test_request_required_integer_unix-nano", + OperationName: "TestRequestRequiredIntegerInt32Nullable", + OperationID: "test_request_required_integer_int32_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = NilInt32 Params = struct{} Response = Error ) @@ -13373,11 +12506,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNano(ctx, request) + return s.h.TestRequestRequiredIntegerInt32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNano(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -13385,23 +12518,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoRequest(args [0]string, return } - if err := encodeTestRequestRequiredIntegerUnixNanoResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNanoArrayRequest handles test_request_required_integer_unix-nano_array operation. +// HandleTestRequestRequiredIntegerInt32NullableArrayRequest handles test_request_required_integer_int32_nullable_array operation. // -// POST /test_request_required_integer_unix-nano_array -func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int32_nullable_array +func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_array"), + otelogen.OperationID("test_request_required_integer_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13425,11 +12558,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNanoArray", - ID: "test_request_required_integer_unix-nano_array", + Name: "TestRequestRequiredIntegerInt32NullableArray", + ID: "test_request_required_integer_int32_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13449,15 +12582,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNanoArray", - OperationID: "test_request_required_integer_unix-nano_array", + OperationName: "TestRequestRequiredIntegerInt32NullableArray", + OperationID: "test_request_required_integer_int32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilInt32 Params = struct{} Response = Error ) @@ -13470,11 +12603,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNanoArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNanoArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -13482,23 +12615,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredIntegerUnixNanoArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNanoArrayArrayRequest handles test_request_required_integer_unix-nano_array_array operation. +// HandleTestRequestRequiredIntegerInt32NullableArrayArrayRequest handles test_request_required_integer_int32_nullable_array_array operation. // -// POST /test_request_required_integer_unix-nano_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int32_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_array_array"), + otelogen.OperationID("test_request_required_integer_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13522,11 +12655,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNanoArrayArray", - ID: "test_request_required_integer_unix-nano_array_array", + Name: "TestRequestRequiredIntegerInt32NullableArrayArray", + ID: "test_request_required_integer_int32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13546,15 +12679,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNanoArrayArray", - OperationID: "test_request_required_integer_unix-nano_array_array", + OperationName: "TestRequestRequiredIntegerInt32NullableArrayArray", + OperationID: "test_request_required_integer_int32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilInt32 Params = struct{} Response = Error ) @@ -13567,11 +12700,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNanoArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -13579,23 +12712,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest(args return } - if err := encodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNanoNullableRequest handles test_request_required_integer_unix-nano_nullable operation. +// HandleTestRequestRequiredIntegerInt64Request handles test_request_required_integer_int64 operation. // -// POST /test_request_required_integer_unix-nano_nullable -func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int64 +func (s *Server) handleTestRequestRequiredIntegerInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_nullable"), + otelogen.OperationID("test_request_required_integer_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13619,11 +12752,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNanoNullable", - ID: "test_request_required_integer_unix-nano_nullable", + Name: "TestRequestRequiredIntegerInt64", + ID: "test_request_required_integer_int64", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13643,15 +12776,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNanoNullable", - OperationID: "test_request_required_integer_unix-nano_nullable", + OperationName: "TestRequestRequiredIntegerInt64", + OperationID: "test_request_required_integer_int64", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilUnixNano + Request = int64 Params = struct{} Response = Error ) @@ -13664,11 +12797,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNanoNullable(ctx, request) + return s.h.TestRequestRequiredIntegerInt64(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNanoNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -13676,23 +12809,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableRequest(args [0 return } - if err := encodeTestRequestRequiredIntegerUnixNanoNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNanoNullableArrayRequest handles test_request_required_integer_unix-nano_nullable_array operation. +// HandleTestRequestRequiredIntegerInt64ArrayRequest handles test_request_required_integer_int64_array operation. // -// POST /test_request_required_integer_unix-nano_nullable_array -func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int64_array +func (s *Server) handleTestRequestRequiredIntegerInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array"), + otelogen.OperationID("test_request_required_integer_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13716,11 +12849,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNanoNullableArray", - ID: "test_request_required_integer_unix-nano_nullable_array", + Name: "TestRequestRequiredIntegerInt64Array", + ID: "test_request_required_integer_int64_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13740,15 +12873,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNanoNullableArray", - OperationID: "test_request_required_integer_unix-nano_nullable_array", + OperationName: "TestRequestRequiredIntegerInt64Array", + OperationID: "test_request_required_integer_int64_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixNano + Request = []int64 Params = struct{} Response = Error ) @@ -13761,11 +12894,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNanoNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt64Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -13773,23 +12906,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest(ar return } - if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest handles test_request_required_integer_unix-nano_nullable_array_array operation. +// HandleTestRequestRequiredIntegerInt64ArrayArrayRequest handles test_request_required_integer_int64_array_array operation. // -// POST /test_request_required_integer_unix-nano_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int64_array_array +func (s *Server) handleTestRequestRequiredIntegerInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13813,11 +12946,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayReque } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNanoNullableArrayArray", - ID: "test_request_required_integer_unix-nano_nullable_array_array", + Name: "TestRequestRequiredIntegerInt64ArrayArray", + ID: "test_request_required_integer_int64_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13837,15 +12970,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayReque if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNanoNullableArrayArray", - OperationID: "test_request_required_integer_unix-nano_nullable_array_array", + OperationName: "TestRequestRequiredIntegerInt64ArrayArray", + OperationID: "test_request_required_integer_int64_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixNano + Request = [][]int64 Params = struct{} Response = Error ) @@ -13858,11 +12991,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayReque mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -13870,23 +13003,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayReque return } - if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNullableRequest handles test_request_required_integer_unix_nullable operation. +// HandleTestRequestRequiredIntegerInt64NullableRequest handles test_request_required_integer_int64_nullable operation. // -// POST /test_request_required_integer_unix_nullable -func (s *Server) handleTestRequestRequiredIntegerUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int64_nullable +func (s *Server) handleTestRequestRequiredIntegerInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_nullable"), + otelogen.OperationID("test_request_required_integer_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -13910,11 +13043,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNullable", - ID: "test_request_required_integer_unix_nullable", + Name: "TestRequestRequiredIntegerInt64Nullable", + ID: "test_request_required_integer_int64_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -13934,15 +13067,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNullable", - OperationID: "test_request_required_integer_unix_nullable", + OperationName: "TestRequestRequiredIntegerInt64Nullable", + OperationID: "test_request_required_integer_int64_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilUnixSeconds + Request = NilInt64 Params = struct{} Response = Error ) @@ -13955,11 +13088,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNullable(ctx, request) + return s.h.TestRequestRequiredIntegerInt64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -13967,23 +13100,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableRequest(args [0]str return } - if err := encodeTestRequestRequiredIntegerUnixNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNullableArrayRequest handles test_request_required_integer_unix_nullable_array operation. +// HandleTestRequestRequiredIntegerInt64NullableArrayRequest handles test_request_required_integer_int64_nullable_array operation. // -// POST /test_request_required_integer_unix_nullable_array -func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int64_nullable_array +func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_nullable_array"), + otelogen.OperationID("test_request_required_integer_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14007,11 +13140,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNullableArray", - ID: "test_request_required_integer_unix_nullable_array", + Name: "TestRequestRequiredIntegerInt64NullableArray", + ID: "test_request_required_integer_int64_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14031,15 +13164,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNullableArray", - OperationID: "test_request_required_integer_unix_nullable_array", + OperationName: "TestRequestRequiredIntegerInt64NullableArray", + OperationID: "test_request_required_integer_int64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixSeconds + Request = []NilInt64 Params = struct{} Response = Error ) @@ -14052,11 +13185,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -14064,23 +13197,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredIntegerUnixNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixNullableArrayArrayRequest handles test_request_required_integer_unix_nullable_array_array operation. +// HandleTestRequestRequiredIntegerInt64NullableArrayArrayRequest handles test_request_required_integer_int64_nullable_array_array operation. // -// POST /test_request_required_integer_unix_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_int64_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14104,11 +13237,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixNullableArrayArray", - ID: "test_request_required_integer_unix_nullable_array_array", + Name: "TestRequestRequiredIntegerInt64NullableArrayArray", + ID: "test_request_required_integer_int64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14128,15 +13261,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixNullableArrayArray", - OperationID: "test_request_required_integer_unix_nullable_array_array", + OperationName: "TestRequestRequiredIntegerInt64NullableArrayArray", + OperationID: "test_request_required_integer_int64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixSeconds + Request = [][]NilInt64 Params = struct{} Response = Error ) @@ -14149,11 +13282,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerInt64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -14161,23 +13294,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixSecondsRequest handles test_request_required_integer_unix-seconds operation. +// HandleTestRequestRequiredIntegerNullableRequest handles test_request_required_integer_nullable operation. // -// POST /test_request_required_integer_unix-seconds -func (s *Server) handleTestRequestRequiredIntegerUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_nullable +func (s *Server) handleTestRequestRequiredIntegerNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds"), + otelogen.OperationID("test_request_required_integer_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSeconds", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14201,11 +13334,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixSeconds", - ID: "test_request_required_integer_unix-seconds", + Name: "TestRequestRequiredIntegerNullable", + ID: "test_request_required_integer_nullable", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14225,15 +13358,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixSeconds", - OperationID: "test_request_required_integer_unix-seconds", + OperationName: "TestRequestRequiredIntegerNullable", + OperationID: "test_request_required_integer_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = NilInt Params = struct{} Response = Error ) @@ -14246,11 +13379,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixSeconds(ctx, request) + return s.h.TestRequestRequiredIntegerNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixSeconds(ctx, request) + response, err = s.h.TestRequestRequiredIntegerNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -14258,23 +13391,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsRequest(args [0]stri return } - if err := encodeTestRequestRequiredIntegerUnixSecondsResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixSecondsArrayRequest handles test_request_required_integer_unix-seconds_array operation. +// HandleTestRequestRequiredIntegerNullableArrayRequest handles test_request_required_integer_nullable_array operation. // -// POST /test_request_required_integer_unix-seconds_array -func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_nullable_array +func (s *Server) handleTestRequestRequiredIntegerNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_array"), + otelogen.OperationID("test_request_required_integer_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14298,11 +13431,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixSecondsArray", - ID: "test_request_required_integer_unix-seconds_array", + Name: "TestRequestRequiredIntegerNullableArray", + ID: "test_request_required_integer_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14322,15 +13455,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixSecondsArray", - OperationID: "test_request_required_integer_unix-seconds_array", + OperationName: "TestRequestRequiredIntegerNullableArray", + OperationID: "test_request_required_integer_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilInt Params = struct{} Response = Error ) @@ -14343,11 +13476,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixSecondsArray(ctx, request) + return s.h.TestRequestRequiredIntegerNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixSecondsArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -14355,23 +13488,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayRequest(args [0 return } - if err := encodeTestRequestRequiredIntegerUnixSecondsArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest handles test_request_required_integer_unix-seconds_array_array operation. +// HandleTestRequestRequiredIntegerNullableArrayArrayRequest handles test_request_required_integer_nullable_array_array operation. // -// POST /test_request_required_integer_unix-seconds_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_array_array"), + otelogen.OperationID("test_request_required_integer_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14395,11 +13528,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixSecondsArrayArray", - ID: "test_request_required_integer_unix-seconds_array_array", + Name: "TestRequestRequiredIntegerNullableArrayArray", + ID: "test_request_required_integer_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14419,15 +13552,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixSecondsArrayArray", - OperationID: "test_request_required_integer_unix-seconds_array_array", + OperationName: "TestRequestRequiredIntegerNullableArrayArray", + OperationID: "test_request_required_integer_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilInt Params = struct{} Response = Error ) @@ -14440,11 +13573,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixSecondsArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -14452,23 +13585,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixSecondsNullableRequest handles test_request_required_integer_unix-seconds_nullable operation. +// HandleTestRequestRequiredIntegerUintRequest handles test_request_required_integer_uint operation. // -// POST /test_request_required_integer_unix-seconds_nullable -func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint +func (s *Server) handleTestRequestRequiredIntegerUintRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_nullable"), + otelogen.OperationID("test_request_required_integer_uint"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14492,11 +13625,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixSecondsNullable", - ID: "test_request_required_integer_unix-seconds_nullable", + Name: "TestRequestRequiredIntegerUint", + ID: "test_request_required_integer_uint", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUintRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14516,15 +13649,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixSecondsNullable", - OperationID: "test_request_required_integer_unix-seconds_nullable", + OperationName: "TestRequestRequiredIntegerUint", + OperationID: "test_request_required_integer_uint", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilUnixSeconds + Request = uint Params = struct{} Response = Error ) @@ -14537,11 +13670,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixSecondsNullable(ctx, request) + return s.h.TestRequestRequiredIntegerUint(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint(ctx, request) } if err != nil { recordError("Internal", err) @@ -14549,23 +13682,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableRequest(args return } - if err := encodeTestRequestRequiredIntegerUnixSecondsNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUintResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest handles test_request_required_integer_unix-seconds_nullable_array operation. +// HandleTestRequestRequiredIntegerUint32Request handles test_request_required_integer_uint32 operation. // -// POST /test_request_required_integer_unix-seconds_nullable_array -func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint32 +func (s *Server) handleTestRequestRequiredIntegerUint32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_required_integer_uint32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14589,11 +13722,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixSecondsNullableArray", - ID: "test_request_required_integer_unix-seconds_nullable_array", + Name: "TestRequestRequiredIntegerUint32", + ID: "test_request_required_integer_uint32", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14613,15 +13746,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixSecondsNullableArray", - OperationID: "test_request_required_integer_unix-seconds_nullable_array", + OperationName: "TestRequestRequiredIntegerUint32", + OperationID: "test_request_required_integer_uint32", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUnixSeconds + Request = uint32 Params = struct{} Response = Error ) @@ -14634,11 +13767,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixSecondsNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint32(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint32(ctx, request) } if err != nil { recordError("Internal", err) @@ -14646,23 +13779,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest return } - if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest handles test_request_required_integer_unix-seconds_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUint32ArrayRequest handles test_request_required_integer_uint32_array operation. // -// POST /test_request_required_integer_unix-seconds_nullable_array_array -func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint32_array +func (s *Server) handleTestRequestRequiredIntegerUint32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_uint32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14686,11 +13819,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRe } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", - ID: "test_request_required_integer_unix-seconds_nullable_array_array", + Name: "TestRequestRequiredIntegerUint32Array", + ID: "test_request_required_integer_uint32_array", } ) - request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14710,15 +13843,15 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRe if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", - OperationID: "test_request_required_integer_unix-seconds_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUint32Array", + OperationID: "test_request_required_integer_uint32_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUnixSeconds + Request = []uint32 Params = struct{} Response = Error ) @@ -14731,11 +13864,11 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRe mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredIntegerUnixSecondsNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint32Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredIntegerUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -14743,23 +13876,23 @@ func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRe return } - if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNullRequest handles test_request_required_null operation. +// HandleTestRequestRequiredIntegerUint32ArrayArrayRequest handles test_request_required_integer_uint32_array_array operation. // -// POST /test_request_required_null -func (s *Server) handleTestRequestRequiredNullRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint32_array_array +func (s *Server) handleTestRequestRequiredIntegerUint32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null"), + otelogen.OperationID("test_request_required_integer_uint32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNull", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14783,11 +13916,11 @@ func (s *Server) handleTestRequestRequiredNullRequest(args [0]string, w http.Res } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNull", - ID: "test_request_required_null", + Name: "TestRequestRequiredIntegerUint32ArrayArray", + ID: "test_request_required_integer_uint32_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNullRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14807,15 +13940,15 @@ func (s *Server) handleTestRequestRequiredNullRequest(args [0]string, w http.Res if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNull", - OperationID: "test_request_required_null", + OperationName: "TestRequestRequiredIntegerUint32ArrayArray", + OperationID: "test_request_required_integer_uint32_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = struct{} + Request = [][]uint32 Params = struct{} Response = Error ) @@ -14828,11 +13961,11 @@ func (s *Server) handleTestRequestRequiredNullRequest(args [0]string, w http.Res mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNull(ctx, request) + return s.h.TestRequestRequiredIntegerUint32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNull(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -14840,23 +13973,23 @@ func (s *Server) handleTestRequestRequiredNullRequest(args [0]string, w http.Res return } - if err := encodeTestRequestRequiredNullResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNullArrayRequest handles test_request_required_null_array operation. +// HandleTestRequestRequiredIntegerUint32NullableRequest handles test_request_required_integer_uint32_nullable operation. // -// POST /test_request_required_null_array -func (s *Server) handleTestRequestRequiredNullArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint32_nullable +func (s *Server) handleTestRequestRequiredIntegerUint32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_array"), + otelogen.OperationID("test_request_required_integer_uint32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14880,11 +14013,11 @@ func (s *Server) handleTestRequestRequiredNullArrayRequest(args [0]string, w htt } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNullArray", - ID: "test_request_required_null_array", + Name: "TestRequestRequiredIntegerUint32Nullable", + ID: "test_request_required_integer_uint32_nullable", } ) - request, close, err := s.decodeTestRequestRequiredNullArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -14904,15 +14037,15 @@ func (s *Server) handleTestRequestRequiredNullArrayRequest(args [0]string, w htt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNullArray", - OperationID: "test_request_required_null_array", + OperationName: "TestRequestRequiredIntegerUint32Nullable", + OperationID: "test_request_required_integer_uint32_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []struct{} + Request = NilUint32 Params = struct{} Response = Error ) @@ -14925,11 +14058,11 @@ func (s *Server) handleTestRequestRequiredNullArrayRequest(args [0]string, w htt mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNullArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNullArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -14937,23 +14070,23 @@ func (s *Server) handleTestRequestRequiredNullArrayRequest(args [0]string, w htt return } - if err := encodeTestRequestRequiredNullArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNullArrayArrayRequest handles test_request_required_null_array_array operation. +// HandleTestRequestRequiredIntegerUint32NullableArrayRequest handles test_request_required_integer_uint32_nullable_array operation. // -// POST /test_request_required_null_array_array -func (s *Server) handleTestRequestRequiredNullArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint32_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUint32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_array_array"), + otelogen.OperationID("test_request_required_integer_uint32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -14977,11 +14110,11 @@ func (s *Server) handleTestRequestRequiredNullArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNullArrayArray", - ID: "test_request_required_null_array_array", + Name: "TestRequestRequiredIntegerUint32NullableArray", + ID: "test_request_required_integer_uint32_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredNullArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15001,15 +14134,15 @@ func (s *Server) handleTestRequestRequiredNullArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNullArrayArray", - OperationID: "test_request_required_null_array_array", + OperationName: "TestRequestRequiredIntegerUint32NullableArray", + OperationID: "test_request_required_integer_uint32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]struct{} + Request = []NilUint32 Params = struct{} Response = Error ) @@ -15022,11 +14155,11 @@ func (s *Server) handleTestRequestRequiredNullArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNullArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNullArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -15034,23 +14167,23 @@ func (s *Server) handleTestRequestRequiredNullArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredNullArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNullNullableRequest handles test_request_required_null_nullable operation. +// HandleTestRequestRequiredIntegerUint32NullableArrayArrayRequest handles test_request_required_integer_uint32_nullable_array_array operation. // -// POST /test_request_required_null_nullable -func (s *Server) handleTestRequestRequiredNullNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint32_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUint32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_nullable"), + otelogen.OperationID("test_request_required_integer_uint32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15074,11 +14207,11 @@ func (s *Server) handleTestRequestRequiredNullNullableRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNullNullable", - ID: "test_request_required_null_nullable", + Name: "TestRequestRequiredIntegerUint32NullableArrayArray", + ID: "test_request_required_integer_uint32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNullNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15098,15 +14231,15 @@ func (s *Server) handleTestRequestRequiredNullNullableRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNullNullable", - OperationID: "test_request_required_null_nullable", + OperationName: "TestRequestRequiredIntegerUint32NullableArrayArray", + OperationID: "test_request_required_integer_uint32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = struct{} + Request = [][]NilUint32 Params = struct{} Response = Error ) @@ -15119,11 +14252,11 @@ func (s *Server) handleTestRequestRequiredNullNullableRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNullNullable(ctx, request) + return s.h.TestRequestRequiredIntegerUint32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNullNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -15131,23 +14264,23 @@ func (s *Server) handleTestRequestRequiredNullNullableRequest(args [0]string, w return } - if err := encodeTestRequestRequiredNullNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNullNullableArrayRequest handles test_request_required_null_nullable_array operation. +// HandleTestRequestRequiredIntegerUint64Request handles test_request_required_integer_uint64 operation. // -// POST /test_request_required_null_nullable_array -func (s *Server) handleTestRequestRequiredNullNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint64 +func (s *Server) handleTestRequestRequiredIntegerUint64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_nullable_array"), + otelogen.OperationID("test_request_required_integer_uint64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15171,11 +14304,11 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNullNullableArray", - ID: "test_request_required_null_nullable_array", + Name: "TestRequestRequiredIntegerUint64", + ID: "test_request_required_integer_uint64", } ) - request, close, err := s.decodeTestRequestRequiredNullNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15195,15 +14328,15 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNullNullableArray", - OperationID: "test_request_required_null_nullable_array", + OperationName: "TestRequestRequiredIntegerUint64", + OperationID: "test_request_required_integer_uint64", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []struct{} + Request = uint64 Params = struct{} Response = Error ) @@ -15216,11 +14349,11 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNullNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint64(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNullNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint64(ctx, request) } if err != nil { recordError("Internal", err) @@ -15228,23 +14361,23 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredNullNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNullNullableArrayArrayRequest handles test_request_required_null_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUint64ArrayRequest handles test_request_required_integer_uint64_array operation. // -// POST /test_request_required_null_nullable_array_array -func (s *Server) handleTestRequestRequiredNullNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint64_array +func (s *Server) handleTestRequestRequiredIntegerUint64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_null_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_uint64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15268,11 +14401,11 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNullNullableArrayArray", - ID: "test_request_required_null_nullable_array_array", + Name: "TestRequestRequiredIntegerUint64Array", + ID: "test_request_required_integer_uint64_array", } ) - request, close, err := s.decodeTestRequestRequiredNullNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15292,15 +14425,15 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNullNullableArrayArray", - OperationID: "test_request_required_null_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUint64Array", + OperationID: "test_request_required_integer_uint64_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]struct{} + Request = []uint64 Params = struct{} Response = Error ) @@ -15313,11 +14446,11 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNullNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint64Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNullNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -15325,23 +14458,23 @@ func (s *Server) handleTestRequestRequiredNullNullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredNullNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberRequest handles test_request_required_number operation. +// HandleTestRequestRequiredIntegerUint64ArrayArrayRequest handles test_request_required_integer_uint64_array_array operation. // -// POST /test_request_required_number -func (s *Server) handleTestRequestRequiredNumberRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint64_array_array +func (s *Server) handleTestRequestRequiredIntegerUint64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number"), + otelogen.OperationID("test_request_required_integer_uint64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumber", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15365,11 +14498,11 @@ func (s *Server) handleTestRequestRequiredNumberRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumber", - ID: "test_request_required_number", + Name: "TestRequestRequiredIntegerUint64ArrayArray", + ID: "test_request_required_integer_uint64_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15389,15 +14522,15 @@ func (s *Server) handleTestRequestRequiredNumberRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumber", - OperationID: "test_request_required_number", + OperationName: "TestRequestRequiredIntegerUint64ArrayArray", + OperationID: "test_request_required_integer_uint64_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = float64 + Request = [][]uint64 Params = struct{} Response = Error ) @@ -15410,11 +14543,11 @@ func (s *Server) handleTestRequestRequiredNumberRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumber(ctx, request) + return s.h.TestRequestRequiredIntegerUint64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumber(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -15422,23 +14555,23 @@ func (s *Server) handleTestRequestRequiredNumberRequest(args [0]string, w http.R return } - if err := encodeTestRequestRequiredNumberResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberArrayRequest handles test_request_required_number_array operation. +// HandleTestRequestRequiredIntegerUint64NullableRequest handles test_request_required_integer_uint64_nullable operation. // -// POST /test_request_required_number_array -func (s *Server) handleTestRequestRequiredNumberArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint64_nullable +func (s *Server) handleTestRequestRequiredIntegerUint64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_array"), + otelogen.OperationID("test_request_required_integer_uint64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15462,11 +14595,11 @@ func (s *Server) handleTestRequestRequiredNumberArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberArray", - ID: "test_request_required_number_array", + Name: "TestRequestRequiredIntegerUint64Nullable", + ID: "test_request_required_integer_uint64_nullable", } ) - request, close, err := s.decodeTestRequestRequiredNumberArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15486,15 +14619,15 @@ func (s *Server) handleTestRequestRequiredNumberArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberArray", - OperationID: "test_request_required_number_array", + OperationName: "TestRequestRequiredIntegerUint64Nullable", + OperationID: "test_request_required_integer_uint64_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []float64 + Request = NilUint64 Params = struct{} Response = Error ) @@ -15507,11 +14640,11 @@ func (s *Server) handleTestRequestRequiredNumberArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -15519,23 +14652,23 @@ func (s *Server) handleTestRequestRequiredNumberArrayRequest(args [0]string, w h return } - if err := encodeTestRequestRequiredNumberArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberArrayArrayRequest handles test_request_required_number_array_array operation. +// HandleTestRequestRequiredIntegerUint64NullableArrayRequest handles test_request_required_integer_uint64_nullable_array operation. // -// POST /test_request_required_number_array_array -func (s *Server) handleTestRequestRequiredNumberArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint64_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUint64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_array_array"), + otelogen.OperationID("test_request_required_integer_uint64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15559,11 +14692,11 @@ func (s *Server) handleTestRequestRequiredNumberArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberArrayArray", - ID: "test_request_required_number_array_array", + Name: "TestRequestRequiredIntegerUint64NullableArray", + ID: "test_request_required_integer_uint64_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15583,15 +14716,15 @@ func (s *Server) handleTestRequestRequiredNumberArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberArrayArray", - OperationID: "test_request_required_number_array_array", + OperationName: "TestRequestRequiredIntegerUint64NullableArray", + OperationID: "test_request_required_integer_uint64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]float64 + Request = []NilUint64 Params = struct{} Response = Error ) @@ -15604,11 +14737,11 @@ func (s *Server) handleTestRequestRequiredNumberArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUint64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -15616,23 +14749,23 @@ func (s *Server) handleTestRequestRequiredNumberArrayArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredNumberArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberDoubleRequest handles test_request_required_number_double operation. +// HandleTestRequestRequiredIntegerUint64NullableArrayArrayRequest handles test_request_required_integer_uint64_nullable_array_array operation. // -// POST /test_request_required_number_double -func (s *Server) handleTestRequestRequiredNumberDoubleRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint64_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUint64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double"), + otelogen.OperationID("test_request_required_integer_uint64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDouble", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15656,11 +14789,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberDouble", - ID: "test_request_required_number_double", + Name: "TestRequestRequiredIntegerUint64NullableArrayArray", + ID: "test_request_required_integer_uint64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberDoubleRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUint64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15680,15 +14813,15 @@ func (s *Server) handleTestRequestRequiredNumberDoubleRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberDouble", - OperationID: "test_request_required_number_double", + OperationName: "TestRequestRequiredIntegerUint64NullableArrayArray", + OperationID: "test_request_required_integer_uint64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = float64 + Request = [][]NilUint64 Params = struct{} Response = Error ) @@ -15701,11 +14834,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberDouble(ctx, request) + return s.h.TestRequestRequiredIntegerUint64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberDouble(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUint64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -15713,23 +14846,23 @@ func (s *Server) handleTestRequestRequiredNumberDoubleRequest(args [0]string, w return } - if err := encodeTestRequestRequiredNumberDoubleResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUint64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberDoubleArrayRequest handles test_request_required_number_double_array operation. +// HandleTestRequestRequiredIntegerUintArrayRequest handles test_request_required_integer_uint_array operation. // -// POST /test_request_required_number_double_array -func (s *Server) handleTestRequestRequiredNumberDoubleArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint_array +func (s *Server) handleTestRequestRequiredIntegerUintArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_array"), + otelogen.OperationID("test_request_required_integer_uint_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUintArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15753,11 +14886,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberDoubleArray", - ID: "test_request_required_number_double_array", + Name: "TestRequestRequiredIntegerUintArray", + ID: "test_request_required_integer_uint_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberDoubleArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUintArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15777,15 +14910,15 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberDoubleArray", - OperationID: "test_request_required_number_double_array", + OperationName: "TestRequestRequiredIntegerUintArray", + OperationID: "test_request_required_integer_uint_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []float64 + Request = []uint Params = struct{} Response = Error ) @@ -15798,11 +14931,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberDoubleArray(ctx, request) + return s.h.TestRequestRequiredIntegerUintArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberDoubleArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUintArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -15810,23 +14943,23 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredNumberDoubleArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUintArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberDoubleArrayArrayRequest handles test_request_required_number_double_array_array operation. +// HandleTestRequestRequiredIntegerUintArrayArrayRequest handles test_request_required_integer_uint_array_array operation. // -// POST /test_request_required_number_double_array_array -func (s *Server) handleTestRequestRequiredNumberDoubleArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint_array_array +func (s *Server) handleTestRequestRequiredIntegerUintArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_array_array"), + otelogen.OperationID("test_request_required_integer_uint_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUintArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15850,11 +14983,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberDoubleArrayArray", - ID: "test_request_required_number_double_array_array", + Name: "TestRequestRequiredIntegerUintArrayArray", + ID: "test_request_required_integer_uint_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUintArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15874,15 +15007,15 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberDoubleArrayArray", - OperationID: "test_request_required_number_double_array_array", + OperationName: "TestRequestRequiredIntegerUintArrayArray", + OperationID: "test_request_required_integer_uint_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]float64 + Request = [][]uint Params = struct{} Response = Error ) @@ -15895,11 +15028,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberDoubleArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUintArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberDoubleArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUintArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -15907,23 +15040,23 @@ func (s *Server) handleTestRequestRequiredNumberDoubleArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredNumberDoubleArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUintArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberDoubleNullableRequest handles test_request_required_number_double_nullable operation. +// HandleTestRequestRequiredIntegerUintNullableRequest handles test_request_required_integer_uint_nullable operation. // -// POST /test_request_required_number_double_nullable -func (s *Server) handleTestRequestRequiredNumberDoubleNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint_nullable +func (s *Server) handleTestRequestRequiredIntegerUintNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_nullable"), + otelogen.OperationID("test_request_required_integer_uint_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUintNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -15947,11 +15080,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberDoubleNullable", - ID: "test_request_required_number_double_nullable", + Name: "TestRequestRequiredIntegerUintNullable", + ID: "test_request_required_integer_uint_nullable", } ) - request, close, err := s.decodeTestRequestRequiredNumberDoubleNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUintNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -15971,15 +15104,15 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberDoubleNullable", - OperationID: "test_request_required_number_double_nullable", + OperationName: "TestRequestRequiredIntegerUintNullable", + OperationID: "test_request_required_integer_uint_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilFloat64 + Request = NilUint Params = struct{} Response = Error ) @@ -15992,11 +15125,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberDoubleNullable(ctx, request) + return s.h.TestRequestRequiredIntegerUintNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberDoubleNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUintNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -16004,23 +15137,23 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableRequest(args [0]st return } - if err := encodeTestRequestRequiredNumberDoubleNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUintNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberDoubleNullableArrayRequest handles test_request_required_number_double_nullable_array operation. +// HandleTestRequestRequiredIntegerUintNullableArrayRequest handles test_request_required_integer_uint_nullable_array operation. // -// POST /test_request_required_number_double_nullable_array -func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUintNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_nullable_array"), + otelogen.OperationID("test_request_required_integer_uint_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUintNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16044,11 +15177,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberDoubleNullableArray", - ID: "test_request_required_number_double_nullable_array", + Name: "TestRequestRequiredIntegerUintNullableArray", + ID: "test_request_required_integer_uint_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUintNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16068,15 +15201,15 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberDoubleNullableArray", - OperationID: "test_request_required_number_double_nullable_array", + OperationName: "TestRequestRequiredIntegerUintNullableArray", + OperationID: "test_request_required_integer_uint_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilFloat64 + Request = []NilUint Params = struct{} Response = Error ) @@ -16089,11 +15222,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberDoubleNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUintNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberDoubleNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUintNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -16101,23 +15234,23 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayRequest(args return } - if err := encodeTestRequestRequiredNumberDoubleNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUintNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberDoubleNullableArrayArrayRequest handles test_request_required_number_double_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUintNullableArrayArrayRequest handles test_request_required_integer_uint_nullable_array_array operation. // -// POST /test_request_required_number_double_nullable_array_array -func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_uint_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUintNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_double_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_uint_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUintNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16141,11 +15274,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberDoubleNullableArrayArray", - ID: "test_request_required_number_double_nullable_array_array", + Name: "TestRequestRequiredIntegerUintNullableArrayArray", + ID: "test_request_required_integer_uint_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUintNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16165,15 +15298,15 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberDoubleNullableArrayArray", - OperationID: "test_request_required_number_double_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUintNullableArrayArray", + OperationID: "test_request_required_integer_uint_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilFloat64 + Request = [][]NilUint Params = struct{} Response = Error ) @@ -16186,11 +15319,11 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberDoubleNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUintNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberDoubleNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUintNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -16198,23 +15331,23 @@ func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest( return } - if err := encodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUintNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberFloatRequest handles test_request_required_number_float operation. +// HandleTestRequestRequiredIntegerUnixRequest handles test_request_required_integer_unix operation. // -// POST /test_request_required_number_float -func (s *Server) handleTestRequestRequiredNumberFloatRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix +func (s *Server) handleTestRequestRequiredIntegerUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float"), + otelogen.OperationID("test_request_required_integer_unix"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloat", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnix", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16238,11 +15371,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberFloat", - ID: "test_request_required_number_float", + Name: "TestRequestRequiredIntegerUnix", + ID: "test_request_required_integer_unix", } ) - request, close, err := s.decodeTestRequestRequiredNumberFloatRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16262,15 +15395,15 @@ func (s *Server) handleTestRequestRequiredNumberFloatRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberFloat", - OperationID: "test_request_required_number_float", + OperationName: "TestRequestRequiredIntegerUnix", + OperationID: "test_request_required_integer_unix", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = float32 + Request = time.Time Params = struct{} Response = Error ) @@ -16283,11 +15416,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberFloat(ctx, request) + return s.h.TestRequestRequiredIntegerUnix(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberFloat(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnix(ctx, request) } if err != nil { recordError("Internal", err) @@ -16295,23 +15428,23 @@ func (s *Server) handleTestRequestRequiredNumberFloatRequest(args [0]string, w h return } - if err := encodeTestRequestRequiredNumberFloatResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberFloatArrayRequest handles test_request_required_number_float_array operation. +// HandleTestRequestRequiredIntegerUnixArrayRequest handles test_request_required_integer_unix_array operation. // -// POST /test_request_required_number_float_array -func (s *Server) handleTestRequestRequiredNumberFloatArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix_array +func (s *Server) handleTestRequestRequiredIntegerUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_array"), + otelogen.OperationID("test_request_required_integer_unix_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16335,11 +15468,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberFloatArray", - ID: "test_request_required_number_float_array", + Name: "TestRequestRequiredIntegerUnixArray", + ID: "test_request_required_integer_unix_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberFloatArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16359,15 +15492,15 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberFloatArray", - OperationID: "test_request_required_number_float_array", + OperationName: "TestRequestRequiredIntegerUnixArray", + OperationID: "test_request_required_integer_unix_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []float32 + Request = []time.Time Params = struct{} Response = Error ) @@ -16380,11 +15513,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberFloatArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberFloatArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -16392,23 +15525,23 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredNumberFloatArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberFloatArrayArrayRequest handles test_request_required_number_float_array_array operation. +// HandleTestRequestRequiredIntegerUnixArrayArrayRequest handles test_request_required_integer_unix_array_array operation. // -// POST /test_request_required_number_float_array_array -func (s *Server) handleTestRequestRequiredNumberFloatArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_array_array"), + otelogen.OperationID("test_request_required_integer_unix_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16432,11 +15565,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberFloatArrayArray", - ID: "test_request_required_number_float_array_array", + Name: "TestRequestRequiredIntegerUnixArrayArray", + ID: "test_request_required_integer_unix_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberFloatArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16456,15 +15589,15 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberFloatArrayArray", - OperationID: "test_request_required_number_float_array_array", + OperationName: "TestRequestRequiredIntegerUnixArrayArray", + OperationID: "test_request_required_integer_unix_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]float32 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -16477,11 +15610,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberFloatArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberFloatArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -16489,23 +15622,23 @@ func (s *Server) handleTestRequestRequiredNumberFloatArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredNumberFloatArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberFloatNullableRequest handles test_request_required_number_float_nullable operation. +// HandleTestRequestRequiredIntegerUnixMicroRequest handles test_request_required_integer_unix-micro operation. // -// POST /test_request_required_number_float_nullable -func (s *Server) handleTestRequestRequiredNumberFloatNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-micro +func (s *Server) handleTestRequestRequiredIntegerUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_nullable"), + otelogen.OperationID("test_request_required_integer_unix-micro"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicro", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16529,11 +15662,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberFloatNullable", - ID: "test_request_required_number_float_nullable", + Name: "TestRequestRequiredIntegerUnixMicro", + ID: "test_request_required_integer_unix-micro", } ) - request, close, err := s.decodeTestRequestRequiredNumberFloatNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16553,15 +15686,15 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberFloatNullable", - OperationID: "test_request_required_number_float_nullable", + OperationName: "TestRequestRequiredIntegerUnixMicro", + OperationID: "test_request_required_integer_unix-micro", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilFloat32 + Request = time.Time Params = struct{} Response = Error ) @@ -16574,11 +15707,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberFloatNullable(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMicro(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberFloatNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMicro(ctx, request) } if err != nil { recordError("Internal", err) @@ -16586,23 +15719,23 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableRequest(args [0]str return } - if err := encodeTestRequestRequiredNumberFloatNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberFloatNullableArrayRequest handles test_request_required_number_float_nullable_array operation. +// HandleTestRequestRequiredIntegerUnixMicroArrayRequest handles test_request_required_integer_unix-micro_array operation. // -// POST /test_request_required_number_float_nullable_array -func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-micro_array +func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16626,11 +15759,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberFloatNullableArray", - ID: "test_request_required_number_float_nullable_array", + Name: "TestRequestRequiredIntegerUnixMicroArray", + ID: "test_request_required_integer_unix-micro_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberFloatNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16650,15 +15783,15 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberFloatNullableArray", - OperationID: "test_request_required_number_float_nullable_array", + OperationName: "TestRequestRequiredIntegerUnixMicroArray", + OperationID: "test_request_required_integer_unix-micro_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilFloat32 + Request = []time.Time Params = struct{} Response = Error ) @@ -16671,11 +15804,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberFloatNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMicroArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberFloatNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMicroArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -16683,23 +15816,23 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredNumberFloatNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberFloatNullableArrayArrayRequest handles test_request_required_number_float_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUnixMicroArrayArrayRequest handles test_request_required_integer_unix-micro_array_array operation. // -// POST /test_request_required_number_float_nullable_array_array -func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-micro_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_float_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16723,11 +15856,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberFloatNullableArrayArray", - ID: "test_request_required_number_float_nullable_array_array", + Name: "TestRequestRequiredIntegerUnixMicroArrayArray", + ID: "test_request_required_integer_unix-micro_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16747,15 +15880,15 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberFloatNullableArrayArray", - OperationID: "test_request_required_number_float_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUnixMicroArrayArray", + OperationID: "test_request_required_integer_unix-micro_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilFloat32 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -16768,11 +15901,11 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberFloatNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMicroArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberFloatNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMicroArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -16780,23 +15913,23 @@ func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt32Request handles test_request_required_number_int32 operation. +// HandleTestRequestRequiredIntegerUnixMicroNullableRequest handles test_request_required_integer_unix-micro_nullable operation. // -// POST /test_request_required_number_int32 -func (s *Server) handleTestRequestRequiredNumberInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-micro_nullable +func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32"), + otelogen.OperationID("test_request_required_integer_unix-micro_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16820,11 +15953,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32Request(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt32", - ID: "test_request_required_number_int32", + Name: "TestRequestRequiredIntegerUnixMicroNullable", + ID: "test_request_required_integer_unix-micro_nullable", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt32Request(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16844,15 +15977,15 @@ func (s *Server) handleTestRequestRequiredNumberInt32Request(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt32", - OperationID: "test_request_required_number_int32", + OperationName: "TestRequestRequiredIntegerUnixMicroNullable", + OperationID: "test_request_required_integer_unix-micro_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = int32 + Request = NilUnixMicro Params = struct{} Response = Error ) @@ -16865,11 +15998,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32Request(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt32(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMicroNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt32(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMicroNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -16877,23 +16010,23 @@ func (s *Server) handleTestRequestRequiredNumberInt32Request(args [0]string, w h return } - if err := encodeTestRequestRequiredNumberInt32Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt32ArrayRequest handles test_request_required_number_int32_array operation. +// HandleTestRequestRequiredIntegerUnixMicroNullableArrayRequest handles test_request_required_integer_unix-micro_nullable_array operation. // -// POST /test_request_required_number_int32_array -func (s *Server) handleTestRequestRequiredNumberInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-micro_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -16917,11 +16050,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt32Array", - ID: "test_request_required_number_int32_array", + Name: "TestRequestRequiredIntegerUnixMicroNullableArray", + ID: "test_request_required_integer_unix-micro_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt32ArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -16941,15 +16074,15 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt32Array", - OperationID: "test_request_required_number_int32_array", + OperationName: "TestRequestRequiredIntegerUnixMicroNullableArray", + OperationID: "test_request_required_integer_unix-micro_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int32 + Request = []NilUnixMicro Params = struct{} Response = Error ) @@ -16962,11 +16095,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt32Array(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMicroNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt32Array(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMicroNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -16974,23 +16107,23 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredNumberInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt32ArrayArrayRequest handles test_request_required_number_int32_array_array operation. +// HandleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest handles test_request_required_integer_unix-micro_nullable_array_array operation. // -// POST /test_request_required_number_int32_array_array -func (s *Server) handleTestRequestRequiredNumberInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-micro_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_array_array"), + otelogen.OperationID("test_request_required_integer_unix-micro_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17014,11 +16147,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt32ArrayArray", - ID: "test_request_required_number_int32_array_array", + Name: "TestRequestRequiredIntegerUnixMicroNullableArrayArray", + ID: "test_request_required_integer_unix-micro_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt32ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17038,15 +16171,15 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt32ArrayArray", - OperationID: "test_request_required_number_int32_array_array", + OperationName: "TestRequestRequiredIntegerUnixMicroNullableArrayArray", + OperationID: "test_request_required_integer_unix-micro_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int32 + Request = [][]NilUnixMicro Params = struct{} Response = Error ) @@ -17059,11 +16192,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt32ArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt32ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMicroNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -17071,23 +16204,23 @@ func (s *Server) handleTestRequestRequiredNumberInt32ArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredNumberInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt32NullableRequest handles test_request_required_number_int32_nullable operation. +// HandleTestRequestRequiredIntegerUnixMilliRequest handles test_request_required_integer_unix-milli operation. // -// POST /test_request_required_number_int32_nullable -func (s *Server) handleTestRequestRequiredNumberInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-milli +func (s *Server) handleTestRequestRequiredIntegerUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_nullable"), + otelogen.OperationID("test_request_required_integer_unix-milli"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilli", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17111,11 +16244,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt32Nullable", - ID: "test_request_required_number_int32_nullable", + Name: "TestRequestRequiredIntegerUnixMilli", + ID: "test_request_required_integer_unix-milli", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt32NullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17135,15 +16268,15 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt32Nullable", - OperationID: "test_request_required_number_int32_nullable", + OperationName: "TestRequestRequiredIntegerUnixMilli", + OperationID: "test_request_required_integer_unix-milli", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilInt32 + Request = time.Time Params = struct{} Response = Error ) @@ -17156,11 +16289,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt32Nullable(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMilli(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt32Nullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMilli(ctx, request) } if err != nil { recordError("Internal", err) @@ -17168,23 +16301,23 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableRequest(args [0]str return } - if err := encodeTestRequestRequiredNumberInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt32NullableArrayRequest handles test_request_required_number_int32_nullable_array operation. +// HandleTestRequestRequiredIntegerUnixMilliArrayRequest handles test_request_required_integer_unix-milli_array operation. // -// POST /test_request_required_number_int32_nullable_array -func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-milli_array +func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17208,11 +16341,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt32NullableArray", - ID: "test_request_required_number_int32_nullable_array", + Name: "TestRequestRequiredIntegerUnixMilliArray", + ID: "test_request_required_integer_unix-milli_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt32NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17232,15 +16365,15 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt32NullableArray", - OperationID: "test_request_required_number_int32_nullable_array", + OperationName: "TestRequestRequiredIntegerUnixMilliArray", + OperationID: "test_request_required_integer_unix-milli_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilInt32 + Request = []time.Time Params = struct{} Response = Error ) @@ -17253,11 +16386,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt32NullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMilliArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt32NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMilliArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -17265,23 +16398,23 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredNumberInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt32NullableArrayArrayRequest handles test_request_required_number_int32_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUnixMilliArrayArrayRequest handles test_request_required_integer_unix-milli_array_array operation. // -// POST /test_request_required_number_int32_nullable_array_array -func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-milli_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int32_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17305,11 +16438,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt32NullableArrayArray", - ID: "test_request_required_number_int32_nullable_array_array", + Name: "TestRequestRequiredIntegerUnixMilliArrayArray", + ID: "test_request_required_integer_unix-milli_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17329,15 +16462,15 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt32NullableArrayArray", - OperationID: "test_request_required_number_int32_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUnixMilliArrayArray", + OperationID: "test_request_required_integer_unix-milli_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilInt32 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -17350,11 +16483,11 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt32NullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMilliArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMilliArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -17362,23 +16495,23 @@ func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt64Request handles test_request_required_number_int64 operation. +// HandleTestRequestRequiredIntegerUnixMilliNullableRequest handles test_request_required_integer_unix-milli_nullable operation. // -// POST /test_request_required_number_int64 -func (s *Server) handleTestRequestRequiredNumberInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-milli_nullable +func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64"), + otelogen.OperationID("test_request_required_integer_unix-milli_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17402,11 +16535,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64Request(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt64", - ID: "test_request_required_number_int64", + Name: "TestRequestRequiredIntegerUnixMilliNullable", + ID: "test_request_required_integer_unix-milli_nullable", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt64Request(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17426,15 +16559,15 @@ func (s *Server) handleTestRequestRequiredNumberInt64Request(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt64", - OperationID: "test_request_required_number_int64", + OperationName: "TestRequestRequiredIntegerUnixMilliNullable", + OperationID: "test_request_required_integer_unix-milli_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = int64 + Request = NilUnixMilli Params = struct{} Response = Error ) @@ -17447,11 +16580,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64Request(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt64(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMilliNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt64(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMilliNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -17459,23 +16592,23 @@ func (s *Server) handleTestRequestRequiredNumberInt64Request(args [0]string, w h return } - if err := encodeTestRequestRequiredNumberInt64Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt64ArrayRequest handles test_request_required_number_int64_array operation. +// HandleTestRequestRequiredIntegerUnixMilliNullableArrayRequest handles test_request_required_integer_unix-milli_nullable_array operation. // -// POST /test_request_required_number_int64_array -func (s *Server) handleTestRequestRequiredNumberInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-milli_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17499,11 +16632,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt64Array", - ID: "test_request_required_number_int64_array", + Name: "TestRequestRequiredIntegerUnixMilliNullableArray", + ID: "test_request_required_integer_unix-milli_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt64ArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17523,15 +16656,15 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt64Array", - OperationID: "test_request_required_number_int64_array", + OperationName: "TestRequestRequiredIntegerUnixMilliNullableArray", + OperationID: "test_request_required_integer_unix-milli_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int64 + Request = []NilUnixMilli Params = struct{} Response = Error ) @@ -17544,11 +16677,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt64Array(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMilliNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt64Array(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMilliNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -17556,23 +16689,23 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredNumberInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt64ArrayArrayRequest handles test_request_required_number_int64_array_array operation. +// HandleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest handles test_request_required_integer_unix-milli_nullable_array_array operation. // -// POST /test_request_required_number_int64_array_array -func (s *Server) handleTestRequestRequiredNumberInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-milli_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_array_array"), + otelogen.OperationID("test_request_required_integer_unix-milli_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17596,11 +16729,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt64ArrayArray", - ID: "test_request_required_number_int64_array_array", + Name: "TestRequestRequiredIntegerUnixMilliNullableArrayArray", + ID: "test_request_required_integer_unix-milli_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt64ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17620,15 +16753,15 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt64ArrayArray", - OperationID: "test_request_required_number_int64_array_array", + OperationName: "TestRequestRequiredIntegerUnixMilliNullableArrayArray", + OperationID: "test_request_required_integer_unix-milli_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int64 + Request = [][]NilUnixMilli Params = struct{} Response = Error ) @@ -17641,11 +16774,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt64ArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt64ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixMilliNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -17653,23 +16786,23 @@ func (s *Server) handleTestRequestRequiredNumberInt64ArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredNumberInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt64NullableRequest handles test_request_required_number_int64_nullable operation. +// HandleTestRequestRequiredIntegerUnixNanoRequest handles test_request_required_integer_unix-nano operation. // -// POST /test_request_required_number_int64_nullable -func (s *Server) handleTestRequestRequiredNumberInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-nano +func (s *Server) handleTestRequestRequiredIntegerUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_nullable"), + otelogen.OperationID("test_request_required_integer_unix-nano"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNano", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17693,11 +16826,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt64Nullable", - ID: "test_request_required_number_int64_nullable", + Name: "TestRequestRequiredIntegerUnixNano", + ID: "test_request_required_integer_unix-nano", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt64NullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17717,15 +16850,15 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt64Nullable", - OperationID: "test_request_required_number_int64_nullable", + OperationName: "TestRequestRequiredIntegerUnixNano", + OperationID: "test_request_required_integer_unix-nano", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilInt64 + Request = time.Time Params = struct{} Response = Error ) @@ -17738,11 +16871,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt64Nullable(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNano(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt64Nullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNano(ctx, request) } if err != nil { recordError("Internal", err) @@ -17750,23 +16883,23 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableRequest(args [0]str return } - if err := encodeTestRequestRequiredNumberInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt64NullableArrayRequest handles test_request_required_number_int64_nullable_array operation. +// HandleTestRequestRequiredIntegerUnixNanoArrayRequest handles test_request_required_integer_unix-nano_array operation. // -// POST /test_request_required_number_int64_nullable_array -func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-nano_array +func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17790,11 +16923,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt64NullableArray", - ID: "test_request_required_number_int64_nullable_array", + Name: "TestRequestRequiredIntegerUnixNanoArray", + ID: "test_request_required_integer_unix-nano_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt64NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17814,15 +16947,15 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt64NullableArray", - OperationID: "test_request_required_number_int64_nullable_array", + OperationName: "TestRequestRequiredIntegerUnixNanoArray", + OperationID: "test_request_required_integer_unix-nano_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilInt64 + Request = []time.Time Params = struct{} Response = Error ) @@ -17835,11 +16968,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt64NullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNanoArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt64NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNanoArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -17847,23 +16980,23 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredNumberInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberInt64NullableArrayArrayRequest handles test_request_required_number_int64_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUnixNanoArrayArrayRequest handles test_request_required_integer_unix-nano_array_array operation. // -// POST /test_request_required_number_int64_nullable_array_array -func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-nano_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_int64_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17887,11 +17020,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberInt64NullableArrayArray", - ID: "test_request_required_number_int64_nullable_array_array", + Name: "TestRequestRequiredIntegerUnixNanoArrayArray", + ID: "test_request_required_integer_unix-nano_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -17911,15 +17044,15 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberInt64NullableArrayArray", - OperationID: "test_request_required_number_int64_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUnixNanoArrayArray", + OperationID: "test_request_required_integer_unix-nano_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilInt64 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -17932,11 +17065,11 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberInt64NullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNanoArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberInt64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNanoArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -17944,23 +17077,23 @@ func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberNullableRequest handles test_request_required_number_nullable operation. +// HandleTestRequestRequiredIntegerUnixNanoNullableRequest handles test_request_required_integer_unix-nano_nullable operation. // -// POST /test_request_required_number_nullable -func (s *Server) handleTestRequestRequiredNumberNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-nano_nullable +func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_nullable"), + otelogen.OperationID("test_request_required_integer_unix-nano_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -17984,11 +17117,11 @@ func (s *Server) handleTestRequestRequiredNumberNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberNullable", - ID: "test_request_required_number_nullable", + Name: "TestRequestRequiredIntegerUnixNanoNullable", + ID: "test_request_required_integer_unix-nano_nullable", } ) - request, close, err := s.decodeTestRequestRequiredNumberNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18008,15 +17141,15 @@ func (s *Server) handleTestRequestRequiredNumberNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberNullable", - OperationID: "test_request_required_number_nullable", + OperationName: "TestRequestRequiredIntegerUnixNanoNullable", + OperationID: "test_request_required_integer_unix-nano_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilFloat64 + Request = NilUnixNano Params = struct{} Response = Error ) @@ -18029,11 +17162,11 @@ func (s *Server) handleTestRequestRequiredNumberNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberNullable(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNanoNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNanoNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -18041,23 +17174,23 @@ func (s *Server) handleTestRequestRequiredNumberNullableRequest(args [0]string, return } - if err := encodeTestRequestRequiredNumberNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberNullableArrayRequest handles test_request_required_number_nullable_array operation. +// HandleTestRequestRequiredIntegerUnixNanoNullableArrayRequest handles test_request_required_integer_unix-nano_nullable_array operation. // -// POST /test_request_required_number_nullable_array -func (s *Server) handleTestRequestRequiredNumberNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-nano_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18081,11 +17214,11 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberNullableArray", - ID: "test_request_required_number_nullable_array", + Name: "TestRequestRequiredIntegerUnixNanoNullableArray", + ID: "test_request_required_integer_unix-nano_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18105,15 +17238,15 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberNullableArray", - OperationID: "test_request_required_number_nullable_array", + OperationName: "TestRequestRequiredIntegerUnixNanoNullableArray", + OperationID: "test_request_required_integer_unix-nano_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilFloat64 + Request = []NilUnixNano Params = struct{} Response = Error ) @@ -18126,11 +17259,11 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNanoNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNanoNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -18138,23 +17271,23 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredNumberNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredNumberNullableArrayArrayRequest handles test_request_required_number_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest handles test_request_required_integer_unix-nano_nullable_array_array operation. // -// POST /test_request_required_number_nullable_array_array -func (s *Server) handleTestRequestRequiredNumberNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-nano_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_number_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-nano_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18178,11 +17311,11 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredNumberNullableArrayArray", - ID: "test_request_required_number_nullable_array_array", + Name: "TestRequestRequiredIntegerUnixNanoNullableArrayArray", + ID: "test_request_required_integer_unix-nano_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredNumberNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18202,15 +17335,15 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredNumberNullableArrayArray", - OperationID: "test_request_required_number_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUnixNanoNullableArrayArray", + OperationID: "test_request_required_integer_unix-nano_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilFloat64 + Request = [][]NilUnixNano Params = struct{} Response = Error ) @@ -18223,11 +17356,11 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredNumberNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredNumberNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNanoNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -18235,23 +17368,23 @@ func (s *Server) handleTestRequestRequiredNumberNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredNumberNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringRequest handles test_request_required_string operation. +// HandleTestRequestRequiredIntegerUnixNullableRequest handles test_request_required_integer_unix_nullable operation. // -// POST /test_request_required_string -func (s *Server) handleTestRequestRequiredStringRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix_nullable +func (s *Server) handleTestRequestRequiredIntegerUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string"), + otelogen.OperationID("test_request_required_integer_unix_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredString", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18275,11 +17408,11 @@ func (s *Server) handleTestRequestRequiredStringRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredString", - ID: "test_request_required_string", + Name: "TestRequestRequiredIntegerUnixNullable", + ID: "test_request_required_integer_unix_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18299,15 +17432,15 @@ func (s *Server) handleTestRequestRequiredStringRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredString", - OperationID: "test_request_required_string", + OperationName: "TestRequestRequiredIntegerUnixNullable", + OperationID: "test_request_required_integer_unix_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = string + Request = NilUnixSeconds Params = struct{} Response = Error ) @@ -18320,11 +17453,11 @@ func (s *Server) handleTestRequestRequiredStringRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredString(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredString(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -18332,23 +17465,23 @@ func (s *Server) handleTestRequestRequiredStringRequest(args [0]string, w http.R return } - if err := encodeTestRequestRequiredStringResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringArrayRequest handles test_request_required_string_array operation. +// HandleTestRequestRequiredIntegerUnixNullableArrayRequest handles test_request_required_integer_unix_nullable_array operation. // -// POST /test_request_required_string_array -func (s *Server) handleTestRequestRequiredStringArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_array"), + otelogen.OperationID("test_request_required_integer_unix_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18372,11 +17505,11 @@ func (s *Server) handleTestRequestRequiredStringArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringArray", - ID: "test_request_required_string_array", + Name: "TestRequestRequiredIntegerUnixNullableArray", + ID: "test_request_required_integer_unix_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18396,15 +17529,15 @@ func (s *Server) handleTestRequestRequiredStringArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringArray", - OperationID: "test_request_required_string_array", + OperationName: "TestRequestRequiredIntegerUnixNullableArray", + OperationID: "test_request_required_integer_unix_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []NilUnixSeconds Params = struct{} Response = Error ) @@ -18417,11 +17550,11 @@ func (s *Server) handleTestRequestRequiredStringArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -18429,23 +17562,23 @@ func (s *Server) handleTestRequestRequiredStringArrayRequest(args [0]string, w h return } - if err := encodeTestRequestRequiredStringArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringArrayArrayRequest handles test_request_required_string_array_array operation. +// HandleTestRequestRequiredIntegerUnixNullableArrayArrayRequest handles test_request_required_integer_unix_nullable_array_array operation. // -// POST /test_request_required_string_array_array -func (s *Server) handleTestRequestRequiredStringArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_array_array"), + otelogen.OperationID("test_request_required_integer_unix_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18469,11 +17602,11 @@ func (s *Server) handleTestRequestRequiredStringArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringArrayArray", - ID: "test_request_required_string_array_array", + Name: "TestRequestRequiredIntegerUnixNullableArrayArray", + ID: "test_request_required_integer_unix_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18493,15 +17626,15 @@ func (s *Server) handleTestRequestRequiredStringArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringArrayArray", - OperationID: "test_request_required_string_array_array", + OperationName: "TestRequestRequiredIntegerUnixNullableArrayArray", + OperationID: "test_request_required_integer_unix_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]NilUnixSeconds Params = struct{} Response = Error ) @@ -18514,11 +17647,11 @@ func (s *Server) handleTestRequestRequiredStringArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -18526,23 +17659,23 @@ func (s *Server) handleTestRequestRequiredStringArrayArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredStringArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringBinaryRequest handles test_request_required_string_binary operation. +// HandleTestRequestRequiredIntegerUnixSecondsRequest handles test_request_required_integer_unix-seconds operation. // -// POST /test_request_required_string_binary -func (s *Server) handleTestRequestRequiredStringBinaryRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-seconds +func (s *Server) handleTestRequestRequiredIntegerUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary"), + otelogen.OperationID("test_request_required_integer_unix-seconds"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinary", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSeconds", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18566,11 +17699,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringBinary", - ID: "test_request_required_string_binary", + Name: "TestRequestRequiredIntegerUnixSeconds", + ID: "test_request_required_integer_unix-seconds", } ) - request, close, err := s.decodeTestRequestRequiredStringBinaryRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18590,15 +17723,15 @@ func (s *Server) handleTestRequestRequiredStringBinaryRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringBinary", - OperationID: "test_request_required_string_binary", + OperationName: "TestRequestRequiredIntegerUnixSeconds", + OperationID: "test_request_required_integer_unix-seconds", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = string + Request = time.Time Params = struct{} Response = Error ) @@ -18611,11 +17744,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringBinary(ctx, request) + return s.h.TestRequestRequiredIntegerUnixSeconds(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringBinary(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixSeconds(ctx, request) } if err != nil { recordError("Internal", err) @@ -18623,23 +17756,23 @@ func (s *Server) handleTestRequestRequiredStringBinaryRequest(args [0]string, w return } - if err := encodeTestRequestRequiredStringBinaryResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringBinaryArrayRequest handles test_request_required_string_binary_array operation. +// HandleTestRequestRequiredIntegerUnixSecondsArrayRequest handles test_request_required_integer_unix-seconds_array operation. // -// POST /test_request_required_string_binary_array -func (s *Server) handleTestRequestRequiredStringBinaryArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-seconds_array +func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18663,11 +17796,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringBinaryArray", - ID: "test_request_required_string_binary_array", + Name: "TestRequestRequiredIntegerUnixSecondsArray", + ID: "test_request_required_integer_unix-seconds_array", } ) - request, close, err := s.decodeTestRequestRequiredStringBinaryArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18687,15 +17820,15 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringBinaryArray", - OperationID: "test_request_required_string_binary_array", + OperationName: "TestRequestRequiredIntegerUnixSecondsArray", + OperationID: "test_request_required_integer_unix-seconds_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []time.Time Params = struct{} Response = Error ) @@ -18708,11 +17841,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringBinaryArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixSecondsArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringBinaryArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixSecondsArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -18720,23 +17853,23 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringBinaryArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringBinaryArrayArrayRequest handles test_request_required_string_binary_array_array operation. +// HandleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest handles test_request_required_integer_unix-seconds_array_array operation. // -// POST /test_request_required_string_binary_array_array -func (s *Server) handleTestRequestRequiredStringBinaryArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-seconds_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_array_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18760,11 +17893,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringBinaryArrayArray", - ID: "test_request_required_string_binary_array_array", + Name: "TestRequestRequiredIntegerUnixSecondsArrayArray", + ID: "test_request_required_integer_unix-seconds_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringBinaryArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18784,15 +17917,15 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringBinaryArrayArray", - OperationID: "test_request_required_string_binary_array_array", + OperationName: "TestRequestRequiredIntegerUnixSecondsArrayArray", + OperationID: "test_request_required_integer_unix-seconds_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]time.Time Params = struct{} Response = Error ) @@ -18805,11 +17938,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringBinaryArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixSecondsArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringBinaryArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixSecondsArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -18817,23 +17950,23 @@ func (s *Server) handleTestRequestRequiredStringBinaryArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringBinaryArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringBinaryNullableRequest handles test_request_required_string_binary_nullable operation. +// HandleTestRequestRequiredIntegerUnixSecondsNullableRequest handles test_request_required_integer_unix-seconds_nullable operation. // -// POST /test_request_required_string_binary_nullable -func (s *Server) handleTestRequestRequiredStringBinaryNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-seconds_nullable +func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_nullable"), + otelogen.OperationID("test_request_required_integer_unix-seconds_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18857,11 +17990,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringBinaryNullable", - ID: "test_request_required_string_binary_nullable", + Name: "TestRequestRequiredIntegerUnixSecondsNullable", + ID: "test_request_required_integer_unix-seconds_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringBinaryNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18881,15 +18014,15 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringBinaryNullable", - OperationID: "test_request_required_string_binary_nullable", + OperationName: "TestRequestRequiredIntegerUnixSecondsNullable", + OperationID: "test_request_required_integer_unix-seconds_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilString + Request = NilUnixSeconds Params = struct{} Response = Error ) @@ -18902,11 +18035,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringBinaryNullable(ctx, request) + return s.h.TestRequestRequiredIntegerUnixSecondsNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringBinaryNullable(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixSecondsNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -18914,23 +18047,23 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableRequest(args [0]st return } - if err := encodeTestRequestRequiredStringBinaryNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringBinaryNullableArrayRequest handles test_request_required_string_binary_nullable_array operation. +// HandleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest handles test_request_required_integer_unix-seconds_nullable_array operation. // -// POST /test_request_required_string_binary_nullable_array -func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-seconds_nullable_array +func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_nullable_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -18954,11 +18087,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringBinaryNullableArray", - ID: "test_request_required_string_binary_nullable_array", + Name: "TestRequestRequiredIntegerUnixSecondsNullableArray", + ID: "test_request_required_integer_unix-seconds_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringBinaryNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -18978,15 +18111,15 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringBinaryNullableArray", - OperationID: "test_request_required_string_binary_nullable_array", + OperationName: "TestRequestRequiredIntegerUnixSecondsNullableArray", + OperationID: "test_request_required_integer_unix-seconds_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []NilUnixSeconds Params = struct{} Response = Error ) @@ -18999,11 +18132,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringBinaryNullableArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixSecondsNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringBinaryNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixSecondsNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19011,23 +18144,23 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayRequest(args return } - if err := encodeTestRequestRequiredStringBinaryNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringBinaryNullableArrayArrayRequest handles test_request_required_string_binary_nullable_array_array operation. +// HandleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest handles test_request_required_integer_unix-seconds_nullable_array_array operation. // -// POST /test_request_required_string_binary_nullable_array_array -func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_integer_unix-seconds_nullable_array_array +func (s *Server) handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_binary_nullable_array_array"), + otelogen.OperationID("test_request_required_integer_unix-seconds_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19051,11 +18184,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringBinaryNullableArrayArray", - ID: "test_request_required_string_binary_nullable_array_array", + Name: "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", + ID: "test_request_required_integer_unix-seconds_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19075,15 +18208,15 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringBinaryNullableArrayArray", - OperationID: "test_request_required_string_binary_nullable_array_array", + OperationName: "TestRequestRequiredIntegerUnixSecondsNullableArrayArray", + OperationID: "test_request_required_integer_unix-seconds_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilUnixSeconds Params = struct{} Response = Error ) @@ -19096,11 +18229,11 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringBinaryNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredIntegerUnixSecondsNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringBinaryNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredIntegerUnixSecondsNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19108,23 +18241,23 @@ func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayArrayRequest( return } - if err := encodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringByteRequest handles test_request_required_string_byte operation. +// HandleTestRequestRequiredNullRequest handles test_request_required_null operation. // -// POST /test_request_required_string_byte -func (s *Server) handleTestRequestRequiredStringByteRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_null +func (s *Server) handleTestRequestRequiredNullRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte"), + otelogen.OperationID("test_request_required_null"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByte", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNull", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19148,11 +18281,11 @@ func (s *Server) handleTestRequestRequiredStringByteRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringByte", - ID: "test_request_required_string_byte", + Name: "TestRequestRequiredNull", + ID: "test_request_required_null", } ) - request, close, err := s.decodeTestRequestRequiredStringByteRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNullRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19172,15 +18305,15 @@ func (s *Server) handleTestRequestRequiredStringByteRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringByte", - OperationID: "test_request_required_string_byte", + OperationName: "TestRequestRequiredNull", + OperationID: "test_request_required_null", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []byte + Request = struct{} Params = struct{} Response = Error ) @@ -19193,11 +18326,11 @@ func (s *Server) handleTestRequestRequiredStringByteRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringByte(ctx, request) + return s.h.TestRequestRequiredNull(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringByte(ctx, request) + response, err = s.h.TestRequestRequiredNull(ctx, request) } if err != nil { recordError("Internal", err) @@ -19205,23 +18338,23 @@ func (s *Server) handleTestRequestRequiredStringByteRequest(args [0]string, w ht return } - if err := encodeTestRequestRequiredStringByteResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNullResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringByteArrayRequest handles test_request_required_string_byte_array operation. +// HandleTestRequestRequiredNullArrayRequest handles test_request_required_null_array operation. // -// POST /test_request_required_string_byte_array -func (s *Server) handleTestRequestRequiredStringByteArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_null_array +func (s *Server) handleTestRequestRequiredNullArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_array"), + otelogen.OperationID("test_request_required_null_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19245,11 +18378,11 @@ func (s *Server) handleTestRequestRequiredStringByteArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringByteArray", - ID: "test_request_required_string_byte_array", + Name: "TestRequestRequiredNullArray", + ID: "test_request_required_null_array", } ) - request, close, err := s.decodeTestRequestRequiredStringByteArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNullArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19269,15 +18402,15 @@ func (s *Server) handleTestRequestRequiredStringByteArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringByteArray", - OperationID: "test_request_required_string_byte_array", + OperationName: "TestRequestRequiredNullArray", + OperationID: "test_request_required_null_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]byte + Request = []struct{} Params = struct{} Response = Error ) @@ -19290,11 +18423,11 @@ func (s *Server) handleTestRequestRequiredStringByteArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringByteArray(ctx, request) + return s.h.TestRequestRequiredNullArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringByteArray(ctx, request) + response, err = s.h.TestRequestRequiredNullArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19302,23 +18435,23 @@ func (s *Server) handleTestRequestRequiredStringByteArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringByteArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNullArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringByteArrayArrayRequest handles test_request_required_string_byte_array_array operation. +// HandleTestRequestRequiredNullArrayArrayRequest handles test_request_required_null_array_array operation. // -// POST /test_request_required_string_byte_array_array -func (s *Server) handleTestRequestRequiredStringByteArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_null_array_array +func (s *Server) handleTestRequestRequiredNullArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_array_array"), + otelogen.OperationID("test_request_required_null_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19342,11 +18475,11 @@ func (s *Server) handleTestRequestRequiredStringByteArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringByteArrayArray", - ID: "test_request_required_string_byte_array_array", + Name: "TestRequestRequiredNullArrayArray", + ID: "test_request_required_null_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringByteArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNullArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19366,15 +18499,15 @@ func (s *Server) handleTestRequestRequiredStringByteArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringByteArrayArray", - OperationID: "test_request_required_string_byte_array_array", + OperationName: "TestRequestRequiredNullArrayArray", + OperationID: "test_request_required_null_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]struct{} Params = struct{} Response = Error ) @@ -19387,11 +18520,11 @@ func (s *Server) handleTestRequestRequiredStringByteArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringByteArrayArray(ctx, request) + return s.h.TestRequestRequiredNullArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringByteArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNullArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19399,23 +18532,23 @@ func (s *Server) handleTestRequestRequiredStringByteArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringByteArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNullArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringByteNullableRequest handles test_request_required_string_byte_nullable operation. +// HandleTestRequestRequiredNullNullableRequest handles test_request_required_null_nullable operation. // -// POST /test_request_required_string_byte_nullable -func (s *Server) handleTestRequestRequiredStringByteNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_null_nullable +func (s *Server) handleTestRequestRequiredNullNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_nullable"), + otelogen.OperationID("test_request_required_null_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19439,11 +18572,11 @@ func (s *Server) handleTestRequestRequiredStringByteNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringByteNullable", - ID: "test_request_required_string_byte_nullable", + Name: "TestRequestRequiredNullNullable", + ID: "test_request_required_null_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringByteNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNullNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19463,15 +18596,15 @@ func (s *Server) handleTestRequestRequiredStringByteNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringByteNullable", - OperationID: "test_request_required_string_byte_nullable", + OperationName: "TestRequestRequiredNullNullable", + OperationID: "test_request_required_null_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []byte + Request = struct{} Params = struct{} Response = Error ) @@ -19484,11 +18617,11 @@ func (s *Server) handleTestRequestRequiredStringByteNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringByteNullable(ctx, request) + return s.h.TestRequestRequiredNullNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringByteNullable(ctx, request) + response, err = s.h.TestRequestRequiredNullNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -19496,23 +18629,23 @@ func (s *Server) handleTestRequestRequiredStringByteNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringByteNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNullNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringByteNullableArrayRequest handles test_request_required_string_byte_nullable_array operation. +// HandleTestRequestRequiredNullNullableArrayRequest handles test_request_required_null_nullable_array operation. // -// POST /test_request_required_string_byte_nullable_array -func (s *Server) handleTestRequestRequiredStringByteNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_null_nullable_array +func (s *Server) handleTestRequestRequiredNullNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_nullable_array"), + otelogen.OperationID("test_request_required_null_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19536,11 +18669,11 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringByteNullableArray", - ID: "test_request_required_string_byte_nullable_array", + Name: "TestRequestRequiredNullNullableArray", + ID: "test_request_required_null_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringByteNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNullNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19560,15 +18693,15 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringByteNullableArray", - OperationID: "test_request_required_string_byte_nullable_array", + OperationName: "TestRequestRequiredNullNullableArray", + OperationID: "test_request_required_null_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]byte + Request = []struct{} Params = struct{} Response = Error ) @@ -19581,11 +18714,11 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringByteNullableArray(ctx, request) + return s.h.TestRequestRequiredNullNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringByteNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredNullNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19593,23 +18726,23 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringByteNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNullNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringByteNullableArrayArrayRequest handles test_request_required_string_byte_nullable_array_array operation. +// HandleTestRequestRequiredNullNullableArrayArrayRequest handles test_request_required_null_nullable_array_array operation. // -// POST /test_request_required_string_byte_nullable_array_array -func (s *Server) handleTestRequestRequiredStringByteNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_null_nullable_array_array +func (s *Server) handleTestRequestRequiredNullNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_byte_nullable_array_array"), + otelogen.OperationID("test_request_required_null_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNullNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19633,11 +18766,11 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringByteNullableArrayArray", - ID: "test_request_required_string_byte_nullable_array_array", + Name: "TestRequestRequiredNullNullableArrayArray", + ID: "test_request_required_null_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringByteNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNullNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19657,15 +18790,15 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringByteNullableArrayArray", - OperationID: "test_request_required_string_byte_nullable_array_array", + OperationName: "TestRequestRequiredNullNullableArrayArray", + OperationID: "test_request_required_null_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]struct{} Params = struct{} Response = Error ) @@ -19678,11 +18811,11 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringByteNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredNullNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringByteNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNullNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19690,23 +18823,23 @@ func (s *Server) handleTestRequestRequiredStringByteNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringByteNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNullNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateRequest handles test_request_required_string_date operation. +// HandleTestRequestRequiredNumberRequest handles test_request_required_number operation. // -// POST /test_request_required_string_date -func (s *Server) handleTestRequestRequiredStringDateRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number +func (s *Server) handleTestRequestRequiredNumberRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date"), + otelogen.OperationID("test_request_required_number"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDate", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumber", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19730,11 +18863,11 @@ func (s *Server) handleTestRequestRequiredStringDateRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDate", - ID: "test_request_required_string_date", + Name: "TestRequestRequiredNumber", + ID: "test_request_required_number", } ) - request, close, err := s.decodeTestRequestRequiredStringDateRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19754,15 +18887,15 @@ func (s *Server) handleTestRequestRequiredStringDateRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDate", - OperationID: "test_request_required_string_date", + OperationName: "TestRequestRequiredNumber", + OperationID: "test_request_required_number", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = float64 Params = struct{} Response = Error ) @@ -19775,11 +18908,11 @@ func (s *Server) handleTestRequestRequiredStringDateRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDate(ctx, request) + return s.h.TestRequestRequiredNumber(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDate(ctx, request) + response, err = s.h.TestRequestRequiredNumber(ctx, request) } if err != nil { recordError("Internal", err) @@ -19787,23 +18920,23 @@ func (s *Server) handleTestRequestRequiredStringDateRequest(args [0]string, w ht return } - if err := encodeTestRequestRequiredStringDateResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateArrayRequest handles test_request_required_string_date_array operation. +// HandleTestRequestRequiredNumberArrayRequest handles test_request_required_number_array operation. // -// POST /test_request_required_string_date_array -func (s *Server) handleTestRequestRequiredStringDateArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_array +func (s *Server) handleTestRequestRequiredNumberArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_array"), + otelogen.OperationID("test_request_required_number_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19827,11 +18960,11 @@ func (s *Server) handleTestRequestRequiredStringDateArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateArray", - ID: "test_request_required_string_date_array", + Name: "TestRequestRequiredNumberArray", + ID: "test_request_required_number_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19851,15 +18984,15 @@ func (s *Server) handleTestRequestRequiredStringDateArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateArray", - OperationID: "test_request_required_string_date_array", + OperationName: "TestRequestRequiredNumberArray", + OperationID: "test_request_required_number_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []float64 Params = struct{} Response = Error ) @@ -19872,11 +19005,11 @@ func (s *Server) handleTestRequestRequiredStringDateArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateArray(ctx, request) + return s.h.TestRequestRequiredNumberArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19884,23 +19017,23 @@ func (s *Server) handleTestRequestRequiredStringDateArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringDateArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateArrayArrayRequest handles test_request_required_string_date_array_array operation. +// HandleTestRequestRequiredNumberArrayArrayRequest handles test_request_required_number_array_array operation. // -// POST /test_request_required_string_date_array_array -func (s *Server) handleTestRequestRequiredStringDateArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_array_array +func (s *Server) handleTestRequestRequiredNumberArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_array_array"), + otelogen.OperationID("test_request_required_number_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -19924,11 +19057,11 @@ func (s *Server) handleTestRequestRequiredStringDateArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateArrayArray", - ID: "test_request_required_string_date_array_array", + Name: "TestRequestRequiredNumberArrayArray", + ID: "test_request_required_number_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -19948,15 +19081,15 @@ func (s *Server) handleTestRequestRequiredStringDateArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateArrayArray", - OperationID: "test_request_required_string_date_array_array", + OperationName: "TestRequestRequiredNumberArrayArray", + OperationID: "test_request_required_number_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]float64 Params = struct{} Response = Error ) @@ -19969,11 +19102,11 @@ func (s *Server) handleTestRequestRequiredStringDateArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -19981,23 +19114,23 @@ func (s *Server) handleTestRequestRequiredStringDateArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringDateArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateNullableRequest handles test_request_required_string_date_nullable operation. +// HandleTestRequestRequiredNumberDoubleRequest handles test_request_required_number_double operation. // -// POST /test_request_required_string_date_nullable -func (s *Server) handleTestRequestRequiredStringDateNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_double +func (s *Server) handleTestRequestRequiredNumberDoubleRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_nullable"), + otelogen.OperationID("test_request_required_number_double"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDouble", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20021,11 +19154,11 @@ func (s *Server) handleTestRequestRequiredStringDateNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateNullable", - ID: "test_request_required_string_date_nullable", + Name: "TestRequestRequiredNumberDouble", + ID: "test_request_required_number_double", } ) - request, close, err := s.decodeTestRequestRequiredStringDateNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberDoubleRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20045,15 +19178,15 @@ func (s *Server) handleTestRequestRequiredStringDateNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateNullable", - OperationID: "test_request_required_string_date_nullable", + OperationName: "TestRequestRequiredNumberDouble", + OperationID: "test_request_required_number_double", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilDate + Request = float64 Params = struct{} Response = Error ) @@ -20066,11 +19199,11 @@ func (s *Server) handleTestRequestRequiredStringDateNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateNullable(ctx, request) + return s.h.TestRequestRequiredNumberDouble(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateNullable(ctx, request) + response, err = s.h.TestRequestRequiredNumberDouble(ctx, request) } if err != nil { recordError("Internal", err) @@ -20078,23 +19211,23 @@ func (s *Server) handleTestRequestRequiredStringDateNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringDateNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberDoubleResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateNullableArrayRequest handles test_request_required_string_date_nullable_array operation. +// HandleTestRequestRequiredNumberDoubleArrayRequest handles test_request_required_number_double_array operation. // -// POST /test_request_required_string_date_nullable_array -func (s *Server) handleTestRequestRequiredStringDateNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_double_array +func (s *Server) handleTestRequestRequiredNumberDoubleArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_nullable_array"), + otelogen.OperationID("test_request_required_number_double_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20118,11 +19251,11 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateNullableArray", - ID: "test_request_required_string_date_nullable_array", + Name: "TestRequestRequiredNumberDoubleArray", + ID: "test_request_required_number_double_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberDoubleArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20142,15 +19275,15 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateNullableArray", - OperationID: "test_request_required_string_date_nullable_array", + OperationName: "TestRequestRequiredNumberDoubleArray", + OperationID: "test_request_required_number_double_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilDate + Request = []float64 Params = struct{} Response = Error ) @@ -20163,11 +19296,11 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateNullableArray(ctx, request) + return s.h.TestRequestRequiredNumberDoubleArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberDoubleArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -20175,23 +19308,23 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringDateNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberDoubleArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateNullableArrayArrayRequest handles test_request_required_string_date_nullable_array_array operation. +// HandleTestRequestRequiredNumberDoubleArrayArrayRequest handles test_request_required_number_double_array_array operation. // -// POST /test_request_required_string_date_nullable_array_array -func (s *Server) handleTestRequestRequiredStringDateNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_double_array_array +func (s *Server) handleTestRequestRequiredNumberDoubleArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date_nullable_array_array"), + otelogen.OperationID("test_request_required_number_double_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20215,11 +19348,11 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateNullableArrayArray", - ID: "test_request_required_string_date_nullable_array_array", + Name: "TestRequestRequiredNumberDoubleArrayArray", + ID: "test_request_required_number_double_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20239,15 +19372,15 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateNullableArrayArray", - OperationID: "test_request_required_string_date_nullable_array_array", + OperationName: "TestRequestRequiredNumberDoubleArrayArray", + OperationID: "test_request_required_number_double_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilDate + Request = [][]float64 Params = struct{} Response = Error ) @@ -20260,11 +19393,11 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberDoubleArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberDoubleArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -20272,23 +19405,23 @@ func (s *Server) handleTestRequestRequiredStringDateNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringDateNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberDoubleArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateTimeRequest handles test_request_required_string_date-time operation. +// HandleTestRequestRequiredNumberDoubleNullableRequest handles test_request_required_number_double_nullable operation. // -// POST /test_request_required_string_date-time -func (s *Server) handleTestRequestRequiredStringDateTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_double_nullable +func (s *Server) handleTestRequestRequiredNumberDoubleNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time"), + otelogen.OperationID("test_request_required_number_double_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20312,11 +19445,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateTime", - ID: "test_request_required_string_date-time", + Name: "TestRequestRequiredNumberDoubleNullable", + ID: "test_request_required_number_double_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringDateTimeRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberDoubleNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20336,15 +19469,15 @@ func (s *Server) handleTestRequestRequiredStringDateTimeRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateTime", - OperationID: "test_request_required_string_date-time", + OperationName: "TestRequestRequiredNumberDoubleNullable", + OperationID: "test_request_required_number_double_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = NilFloat64 Params = struct{} Response = Error ) @@ -20357,11 +19490,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateTime(ctx, request) + return s.h.TestRequestRequiredNumberDoubleNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateTime(ctx, request) + response, err = s.h.TestRequestRequiredNumberDoubleNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -20369,23 +19502,23 @@ func (s *Server) handleTestRequestRequiredStringDateTimeRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringDateTimeResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberDoubleNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateTimeArrayRequest handles test_request_required_string_date-time_array operation. +// HandleTestRequestRequiredNumberDoubleNullableArrayRequest handles test_request_required_number_double_nullable_array operation. // -// POST /test_request_required_string_date-time_array -func (s *Server) handleTestRequestRequiredStringDateTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_double_nullable_array +func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_array"), + otelogen.OperationID("test_request_required_number_double_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20409,11 +19542,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateTimeArray", - ID: "test_request_required_string_date-time_array", + Name: "TestRequestRequiredNumberDoubleNullableArray", + ID: "test_request_required_number_double_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateTimeArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20433,15 +19566,15 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateTimeArray", - OperationID: "test_request_required_string_date-time_array", + OperationName: "TestRequestRequiredNumberDoubleNullableArray", + OperationID: "test_request_required_number_double_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilFloat64 Params = struct{} Response = Error ) @@ -20454,11 +19587,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateTimeArray(ctx, request) + return s.h.TestRequestRequiredNumberDoubleNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateTimeArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberDoubleNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -20466,23 +19599,23 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringDateTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberDoubleNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateTimeArrayArrayRequest handles test_request_required_string_date-time_array_array operation. +// HandleTestRequestRequiredNumberDoubleNullableArrayArrayRequest handles test_request_required_number_double_nullable_array_array operation. // -// POST /test_request_required_string_date-time_array_array -func (s *Server) handleTestRequestRequiredStringDateTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_double_nullable_array_array +func (s *Server) handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_array_array"), + otelogen.OperationID("test_request_required_number_double_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberDoubleNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20506,11 +19639,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateTimeArrayArray", - ID: "test_request_required_string_date-time_array_array", + Name: "TestRequestRequiredNumberDoubleNullableArrayArray", + ID: "test_request_required_number_double_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20530,15 +19663,15 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateTimeArrayArray", - OperationID: "test_request_required_string_date-time_array_array", + OperationName: "TestRequestRequiredNumberDoubleNullableArrayArray", + OperationID: "test_request_required_number_double_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilFloat64 Params = struct{} Response = Error ) @@ -20551,11 +19684,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateTimeArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberDoubleNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateTimeArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberDoubleNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -20563,23 +19696,23 @@ func (s *Server) handleTestRequestRequiredStringDateTimeArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringDateTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateTimeNullableRequest handles test_request_required_string_date-time_nullable operation. +// HandleTestRequestRequiredNumberFloatRequest handles test_request_required_number_float operation. // -// POST /test_request_required_string_date-time_nullable -func (s *Server) handleTestRequestRequiredStringDateTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_float +func (s *Server) handleTestRequestRequiredNumberFloatRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_nullable"), + otelogen.OperationID("test_request_required_number_float"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloat", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20603,11 +19736,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateTimeNullable", - ID: "test_request_required_string_date-time_nullable", + Name: "TestRequestRequiredNumberFloat", + ID: "test_request_required_number_float", } ) - request, close, err := s.decodeTestRequestRequiredStringDateTimeNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberFloatRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20627,15 +19760,15 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateTimeNullable", - OperationID: "test_request_required_string_date-time_nullable", + OperationName: "TestRequestRequiredNumberFloat", + OperationID: "test_request_required_number_float", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilDateTime + Request = float32 Params = struct{} Response = Error ) @@ -20648,11 +19781,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateTimeNullable(ctx, request) + return s.h.TestRequestRequiredNumberFloat(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateTimeNullable(ctx, request) + response, err = s.h.TestRequestRequiredNumberFloat(ctx, request) } if err != nil { recordError("Internal", err) @@ -20660,23 +19793,23 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableRequest(args [0] return } - if err := encodeTestRequestRequiredStringDateTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberFloatResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateTimeNullableArrayRequest handles test_request_required_string_date-time_nullable_array operation. +// HandleTestRequestRequiredNumberFloatArrayRequest handles test_request_required_number_float_array operation. // -// POST /test_request_required_string_date-time_nullable_array -func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_float_array +func (s *Server) handleTestRequestRequiredNumberFloatArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_nullable_array"), + otelogen.OperationID("test_request_required_number_float_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20700,11 +19833,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateTimeNullableArray", - ID: "test_request_required_string_date-time_nullable_array", + Name: "TestRequestRequiredNumberFloatArray", + ID: "test_request_required_number_float_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateTimeNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberFloatArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20724,15 +19857,15 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateTimeNullableArray", - OperationID: "test_request_required_string_date-time_nullable_array", + OperationName: "TestRequestRequiredNumberFloatArray", + OperationID: "test_request_required_number_float_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilDateTime + Request = []float32 Params = struct{} Response = Error ) @@ -20745,11 +19878,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateTimeNullableArray(ctx, request) + return s.h.TestRequestRequiredNumberFloatArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateTimeNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberFloatArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -20757,23 +19890,23 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayRequest(arg return } - if err := encodeTestRequestRequiredStringDateTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberFloatArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDateTimeNullableArrayArrayRequest handles test_request_required_string_date-time_nullable_array_array operation. +// HandleTestRequestRequiredNumberFloatArrayArrayRequest handles test_request_required_number_float_array_array operation. // -// POST /test_request_required_string_date-time_nullable_array_array -func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_float_array_array +func (s *Server) handleTestRequestRequiredNumberFloatArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_date-time_nullable_array_array"), + otelogen.OperationID("test_request_required_number_float_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20797,11 +19930,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayArrayReques } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDateTimeNullableArrayArray", - ID: "test_request_required_string_date-time_nullable_array_array", + Name: "TestRequestRequiredNumberFloatArrayArray", + ID: "test_request_required_number_float_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDateTimeNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberFloatArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20821,15 +19954,15 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayArrayReques if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDateTimeNullableArrayArray", - OperationID: "test_request_required_string_date-time_nullable_array_array", + OperationName: "TestRequestRequiredNumberFloatArrayArray", + OperationID: "test_request_required_number_float_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilDateTime + Request = [][]float32 Params = struct{} Response = Error ) @@ -20842,11 +19975,11 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayArrayReques mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDateTimeNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberFloatArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDateTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberFloatArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -20854,23 +19987,23 @@ func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayArrayReques return } - if err := encodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberFloatArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDurationRequest handles test_request_required_string_duration operation. +// HandleTestRequestRequiredNumberFloatNullableRequest handles test_request_required_number_float_nullable operation. // -// POST /test_request_required_string_duration -func (s *Server) handleTestRequestRequiredStringDurationRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_float_nullable +func (s *Server) handleTestRequestRequiredNumberFloatNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration"), + otelogen.OperationID("test_request_required_number_float_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDuration", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20894,11 +20027,11 @@ func (s *Server) handleTestRequestRequiredStringDurationRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDuration", - ID: "test_request_required_string_duration", + Name: "TestRequestRequiredNumberFloatNullable", + ID: "test_request_required_number_float_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringDurationRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberFloatNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -20918,15 +20051,15 @@ func (s *Server) handleTestRequestRequiredStringDurationRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDuration", - OperationID: "test_request_required_string_duration", + OperationName: "TestRequestRequiredNumberFloatNullable", + OperationID: "test_request_required_number_float_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Duration + Request = NilFloat32 Params = struct{} Response = Error ) @@ -20939,11 +20072,11 @@ func (s *Server) handleTestRequestRequiredStringDurationRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDuration(ctx, request) + return s.h.TestRequestRequiredNumberFloatNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDuration(ctx, request) + response, err = s.h.TestRequestRequiredNumberFloatNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -20951,23 +20084,23 @@ func (s *Server) handleTestRequestRequiredStringDurationRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringDurationResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberFloatNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDurationArrayRequest handles test_request_required_string_duration_array operation. +// HandleTestRequestRequiredNumberFloatNullableArrayRequest handles test_request_required_number_float_nullable_array operation. // -// POST /test_request_required_string_duration_array -func (s *Server) handleTestRequestRequiredStringDurationArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_float_nullable_array +func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_array"), + otelogen.OperationID("test_request_required_number_float_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -20991,11 +20124,11 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDurationArray", - ID: "test_request_required_string_duration_array", + Name: "TestRequestRequiredNumberFloatNullableArray", + ID: "test_request_required_number_float_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDurationArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberFloatNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21015,15 +20148,15 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDurationArray", - OperationID: "test_request_required_string_duration_array", + OperationName: "TestRequestRequiredNumberFloatNullableArray", + OperationID: "test_request_required_number_float_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Duration + Request = []NilFloat32 Params = struct{} Response = Error ) @@ -21036,11 +20169,11 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDurationArray(ctx, request) + return s.h.TestRequestRequiredNumberFloatNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDurationArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberFloatNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -21048,23 +20181,23 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringDurationArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberFloatNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDurationArrayArrayRequest handles test_request_required_string_duration_array_array operation. +// HandleTestRequestRequiredNumberFloatNullableArrayArrayRequest handles test_request_required_number_float_nullable_array_array operation. // -// POST /test_request_required_string_duration_array_array -func (s *Server) handleTestRequestRequiredStringDurationArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_float_nullable_array_array +func (s *Server) handleTestRequestRequiredNumberFloatNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_array_array"), + otelogen.OperationID("test_request_required_number_float_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberFloatNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21088,11 +20221,11 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDurationArrayArray", - ID: "test_request_required_string_duration_array_array", + Name: "TestRequestRequiredNumberFloatNullableArrayArray", + ID: "test_request_required_number_float_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDurationArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21112,15 +20245,15 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDurationArrayArray", - OperationID: "test_request_required_string_duration_array_array", + OperationName: "TestRequestRequiredNumberFloatNullableArrayArray", + OperationID: "test_request_required_number_float_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Duration + Request = [][]NilFloat32 Params = struct{} Response = Error ) @@ -21133,11 +20266,11 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDurationArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberFloatNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDurationArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberFloatNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -21145,23 +20278,23 @@ func (s *Server) handleTestRequestRequiredStringDurationArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringDurationArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDurationNullableRequest handles test_request_required_string_duration_nullable operation. +// HandleTestRequestRequiredNumberInt32Request handles test_request_required_number_int32 operation. // -// POST /test_request_required_string_duration_nullable -func (s *Server) handleTestRequestRequiredStringDurationNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int32 +func (s *Server) handleTestRequestRequiredNumberInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_nullable"), + otelogen.OperationID("test_request_required_number_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21185,11 +20318,11 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDurationNullable", - ID: "test_request_required_string_duration_nullable", + Name: "TestRequestRequiredNumberInt32", + ID: "test_request_required_number_int32", } ) - request, close, err := s.decodeTestRequestRequiredStringDurationNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21209,15 +20342,15 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDurationNullable", - OperationID: "test_request_required_string_duration_nullable", + OperationName: "TestRequestRequiredNumberInt32", + OperationID: "test_request_required_number_int32", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilDuration + Request = int32 Params = struct{} Response = Error ) @@ -21230,11 +20363,11 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDurationNullable(ctx, request) + return s.h.TestRequestRequiredNumberInt32(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDurationNullable(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -21242,23 +20375,23 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableRequest(args [0] return } - if err := encodeTestRequestRequiredStringDurationNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDurationNullableArrayRequest handles test_request_required_string_duration_nullable_array operation. +// HandleTestRequestRequiredNumberInt32ArrayRequest handles test_request_required_number_int32_array operation. // -// POST /test_request_required_string_duration_nullable_array -func (s *Server) handleTestRequestRequiredStringDurationNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int32_array +func (s *Server) handleTestRequestRequiredNumberInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_nullable_array"), + otelogen.OperationID("test_request_required_number_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21282,11 +20415,11 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDurationNullableArray", - ID: "test_request_required_string_duration_nullable_array", + Name: "TestRequestRequiredNumberInt32Array", + ID: "test_request_required_number_int32_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDurationNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21306,15 +20439,15 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDurationNullableArray", - OperationID: "test_request_required_string_duration_nullable_array", + OperationName: "TestRequestRequiredNumberInt32Array", + OperationID: "test_request_required_number_int32_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilDuration + Request = []int32 Params = struct{} Response = Error ) @@ -21327,11 +20460,11 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDurationNullableArray(ctx, request) + return s.h.TestRequestRequiredNumberInt32Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDurationNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -21339,23 +20472,23 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayRequest(arg return } - if err := encodeTestRequestRequiredStringDurationNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringDurationNullableArrayArrayRequest handles test_request_required_string_duration_nullable_array_array operation. +// HandleTestRequestRequiredNumberInt32ArrayArrayRequest handles test_request_required_number_int32_array_array operation. // -// POST /test_request_required_string_duration_nullable_array_array -func (s *Server) handleTestRequestRequiredStringDurationNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int32_array_array +func (s *Server) handleTestRequestRequiredNumberInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_duration_nullable_array_array"), + otelogen.OperationID("test_request_required_number_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21379,11 +20512,11 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayArrayReques } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringDurationNullableArrayArray", - ID: "test_request_required_string_duration_nullable_array_array", + Name: "TestRequestRequiredNumberInt32ArrayArray", + ID: "test_request_required_number_int32_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringDurationNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21403,15 +20536,15 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayArrayReques if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringDurationNullableArrayArray", - OperationID: "test_request_required_string_duration_nullable_array_array", + OperationName: "TestRequestRequiredNumberInt32ArrayArray", + OperationID: "test_request_required_number_int32_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilDuration + Request = [][]int32 Params = struct{} Response = Error ) @@ -21424,11 +20557,11 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayArrayReques mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringDurationNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberInt32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringDurationNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -21436,23 +20569,23 @@ func (s *Server) handleTestRequestRequiredStringDurationNullableArrayArrayReques return } - if err := encodeTestRequestRequiredStringDurationNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringEmailRequest handles test_request_required_string_email operation. +// HandleTestRequestRequiredNumberInt32NullableRequest handles test_request_required_number_int32_nullable operation. // -// POST /test_request_required_string_email -func (s *Server) handleTestRequestRequiredStringEmailRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int32_nullable +func (s *Server) handleTestRequestRequiredNumberInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email"), + otelogen.OperationID("test_request_required_number_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmail", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21476,11 +20609,11 @@ func (s *Server) handleTestRequestRequiredStringEmailRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringEmail", - ID: "test_request_required_string_email", + Name: "TestRequestRequiredNumberInt32Nullable", + ID: "test_request_required_number_int32_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringEmailRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21500,15 +20633,15 @@ func (s *Server) handleTestRequestRequiredStringEmailRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringEmail", - OperationID: "test_request_required_string_email", + OperationName: "TestRequestRequiredNumberInt32Nullable", + OperationID: "test_request_required_number_int32_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = string + Request = NilInt32 Params = struct{} Response = Error ) @@ -21521,11 +20654,11 @@ func (s *Server) handleTestRequestRequiredStringEmailRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringEmail(ctx, request) + return s.h.TestRequestRequiredNumberInt32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringEmail(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -21533,23 +20666,23 @@ func (s *Server) handleTestRequestRequiredStringEmailRequest(args [0]string, w h return } - if err := encodeTestRequestRequiredStringEmailResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringEmailArrayRequest handles test_request_required_string_email_array operation. +// HandleTestRequestRequiredNumberInt32NullableArrayRequest handles test_request_required_number_int32_nullable_array operation. // -// POST /test_request_required_string_email_array -func (s *Server) handleTestRequestRequiredStringEmailArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int32_nullable_array +func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_array"), + otelogen.OperationID("test_request_required_number_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21573,11 +20706,11 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringEmailArray", - ID: "test_request_required_string_email_array", + Name: "TestRequestRequiredNumberInt32NullableArray", + ID: "test_request_required_number_int32_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringEmailArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21597,15 +20730,15 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringEmailArray", - OperationID: "test_request_required_string_email_array", + OperationName: "TestRequestRequiredNumberInt32NullableArray", + OperationID: "test_request_required_number_int32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []NilInt32 Params = struct{} Response = Error ) @@ -21618,11 +20751,11 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringEmailArray(ctx, request) + return s.h.TestRequestRequiredNumberInt32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringEmailArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -21630,23 +20763,23 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredStringEmailArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringEmailArrayArrayRequest handles test_request_required_string_email_array_array operation. +// HandleTestRequestRequiredNumberInt32NullableArrayArrayRequest handles test_request_required_number_int32_nullable_array_array operation. // -// POST /test_request_required_string_email_array_array -func (s *Server) handleTestRequestRequiredStringEmailArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int32_nullable_array_array +func (s *Server) handleTestRequestRequiredNumberInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_array_array"), + otelogen.OperationID("test_request_required_number_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21670,11 +20803,11 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringEmailArrayArray", - ID: "test_request_required_string_email_array_array", + Name: "TestRequestRequiredNumberInt32NullableArrayArray", + ID: "test_request_required_number_int32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringEmailArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21694,15 +20827,15 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringEmailArrayArray", - OperationID: "test_request_required_string_email_array_array", + OperationName: "TestRequestRequiredNumberInt32NullableArrayArray", + OperationID: "test_request_required_number_int32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]NilInt32 Params = struct{} Response = Error ) @@ -21715,11 +20848,11 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringEmailArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberInt32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringEmailArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -21727,23 +20860,23 @@ func (s *Server) handleTestRequestRequiredStringEmailArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredStringEmailArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringEmailNullableRequest handles test_request_required_string_email_nullable operation. +// HandleTestRequestRequiredNumberInt64Request handles test_request_required_number_int64 operation. // -// POST /test_request_required_string_email_nullable -func (s *Server) handleTestRequestRequiredStringEmailNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int64 +func (s *Server) handleTestRequestRequiredNumberInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_nullable"), + otelogen.OperationID("test_request_required_number_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21767,11 +20900,11 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringEmailNullable", - ID: "test_request_required_string_email_nullable", + Name: "TestRequestRequiredNumberInt64", + ID: "test_request_required_number_int64", } ) - request, close, err := s.decodeTestRequestRequiredStringEmailNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21791,15 +20924,15 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringEmailNullable", - OperationID: "test_request_required_string_email_nullable", + OperationName: "TestRequestRequiredNumberInt64", + OperationID: "test_request_required_number_int64", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilString + Request = int64 Params = struct{} Response = Error ) @@ -21812,11 +20945,11 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringEmailNullable(ctx, request) + return s.h.TestRequestRequiredNumberInt64(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringEmailNullable(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -21824,23 +20957,23 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableRequest(args [0]str return } - if err := encodeTestRequestRequiredStringEmailNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringEmailNullableArrayRequest handles test_request_required_string_email_nullable_array operation. +// HandleTestRequestRequiredNumberInt64ArrayRequest handles test_request_required_number_int64_array operation. // -// POST /test_request_required_string_email_nullable_array -func (s *Server) handleTestRequestRequiredStringEmailNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int64_array +func (s *Server) handleTestRequestRequiredNumberInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_nullable_array"), + otelogen.OperationID("test_request_required_number_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21864,11 +20997,11 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringEmailNullableArray", - ID: "test_request_required_string_email_nullable_array", + Name: "TestRequestRequiredNumberInt64Array", + ID: "test_request_required_number_int64_array", } ) - request, close, err := s.decodeTestRequestRequiredStringEmailNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21888,15 +21021,15 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringEmailNullableArray", - OperationID: "test_request_required_string_email_nullable_array", + OperationName: "TestRequestRequiredNumberInt64Array", + OperationID: "test_request_required_number_int64_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []int64 Params = struct{} Response = Error ) @@ -21909,11 +21042,11 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringEmailNullableArray(ctx, request) + return s.h.TestRequestRequiredNumberInt64Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringEmailNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -21921,23 +21054,23 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringEmailNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringEmailNullableArrayArrayRequest handles test_request_required_string_email_nullable_array_array operation. +// HandleTestRequestRequiredNumberInt64ArrayArrayRequest handles test_request_required_number_int64_array_array operation. // -// POST /test_request_required_string_email_nullable_array_array -func (s *Server) handleTestRequestRequiredStringEmailNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int64_array_array +func (s *Server) handleTestRequestRequiredNumberInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_email_nullable_array_array"), + otelogen.OperationID("test_request_required_number_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -21961,11 +21094,11 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringEmailNullableArrayArray", - ID: "test_request_required_string_email_nullable_array_array", + Name: "TestRequestRequiredNumberInt64ArrayArray", + ID: "test_request_required_number_int64_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -21985,15 +21118,15 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringEmailNullableArrayArray", - OperationID: "test_request_required_string_email_nullable_array_array", + OperationName: "TestRequestRequiredNumberInt64ArrayArray", + OperationID: "test_request_required_number_int64_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]int64 Params = struct{} Response = Error ) @@ -22006,11 +21139,11 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringEmailNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberInt64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringEmailNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -22018,23 +21151,23 @@ func (s *Server) handleTestRequestRequiredStringEmailNullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredStringEmailNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringHostnameRequest handles test_request_required_string_hostname operation. +// HandleTestRequestRequiredNumberInt64NullableRequest handles test_request_required_number_int64_nullable operation. // -// POST /test_request_required_string_hostname -func (s *Server) handleTestRequestRequiredStringHostnameRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int64_nullable +func (s *Server) handleTestRequestRequiredNumberInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname"), + otelogen.OperationID("test_request_required_number_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostname", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22058,11 +21191,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringHostname", - ID: "test_request_required_string_hostname", + Name: "TestRequestRequiredNumberInt64Nullable", + ID: "test_request_required_number_int64_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringHostnameRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22082,15 +21215,15 @@ func (s *Server) handleTestRequestRequiredStringHostnameRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringHostname", - OperationID: "test_request_required_string_hostname", + OperationName: "TestRequestRequiredNumberInt64Nullable", + OperationID: "test_request_required_number_int64_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = string + Request = NilInt64 Params = struct{} Response = Error ) @@ -22103,11 +21236,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringHostname(ctx, request) + return s.h.TestRequestRequiredNumberInt64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringHostname(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -22115,23 +21248,23 @@ func (s *Server) handleTestRequestRequiredStringHostnameRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringHostnameResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringHostnameArrayRequest handles test_request_required_string_hostname_array operation. +// HandleTestRequestRequiredNumberInt64NullableArrayRequest handles test_request_required_number_int64_nullable_array operation. // -// POST /test_request_required_string_hostname_array -func (s *Server) handleTestRequestRequiredStringHostnameArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int64_nullable_array +func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_array"), + otelogen.OperationID("test_request_required_number_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22155,11 +21288,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringHostnameArray", - ID: "test_request_required_string_hostname_array", + Name: "TestRequestRequiredNumberInt64NullableArray", + ID: "test_request_required_number_int64_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringHostnameArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22179,15 +21312,15 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringHostnameArray", - OperationID: "test_request_required_string_hostname_array", + OperationName: "TestRequestRequiredNumberInt64NullableArray", + OperationID: "test_request_required_number_int64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []NilInt64 Params = struct{} Response = Error ) @@ -22200,11 +21333,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringHostnameArray(ctx, request) + return s.h.TestRequestRequiredNumberInt64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringHostnameArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -22212,23 +21345,23 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringHostnameArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringHostnameArrayArrayRequest handles test_request_required_string_hostname_array_array operation. +// HandleTestRequestRequiredNumberInt64NullableArrayArrayRequest handles test_request_required_number_int64_nullable_array_array operation. // -// POST /test_request_required_string_hostname_array_array -func (s *Server) handleTestRequestRequiredStringHostnameArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_int64_nullable_array_array +func (s *Server) handleTestRequestRequiredNumberInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_array_array"), + otelogen.OperationID("test_request_required_number_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22252,11 +21385,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringHostnameArrayArray", - ID: "test_request_required_string_hostname_array_array", + Name: "TestRequestRequiredNumberInt64NullableArrayArray", + ID: "test_request_required_number_int64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringHostnameArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22276,15 +21409,15 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringHostnameArrayArray", - OperationID: "test_request_required_string_hostname_array_array", + OperationName: "TestRequestRequiredNumberInt64NullableArrayArray", + OperationID: "test_request_required_number_int64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]NilInt64 Params = struct{} Response = Error ) @@ -22297,11 +21430,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringHostnameArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberInt64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringHostnameArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -22309,23 +21442,23 @@ func (s *Server) handleTestRequestRequiredStringHostnameArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringHostnameArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringHostnameNullableRequest handles test_request_required_string_hostname_nullable operation. +// HandleTestRequestRequiredNumberNullableRequest handles test_request_required_number_nullable operation. // -// POST /test_request_required_string_hostname_nullable -func (s *Server) handleTestRequestRequiredStringHostnameNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_nullable +func (s *Server) handleTestRequestRequiredNumberNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_nullable"), + otelogen.OperationID("test_request_required_number_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22349,11 +21482,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringHostnameNullable", - ID: "test_request_required_string_hostname_nullable", + Name: "TestRequestRequiredNumberNullable", + ID: "test_request_required_number_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringHostnameNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22373,15 +21506,15 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringHostnameNullable", - OperationID: "test_request_required_string_hostname_nullable", + OperationName: "TestRequestRequiredNumberNullable", + OperationID: "test_request_required_number_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilString + Request = NilFloat64 Params = struct{} Response = Error ) @@ -22394,11 +21527,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringHostnameNullable(ctx, request) + return s.h.TestRequestRequiredNumberNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringHostnameNullable(ctx, request) + response, err = s.h.TestRequestRequiredNumberNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -22406,23 +21539,23 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableRequest(args [0] return } - if err := encodeTestRequestRequiredStringHostnameNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringHostnameNullableArrayRequest handles test_request_required_string_hostname_nullable_array operation. +// HandleTestRequestRequiredNumberNullableArrayRequest handles test_request_required_number_nullable_array operation. // -// POST /test_request_required_string_hostname_nullable_array -func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_nullable_array +func (s *Server) handleTestRequestRequiredNumberNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_nullable_array"), + otelogen.OperationID("test_request_required_number_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22446,11 +21579,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringHostnameNullableArray", - ID: "test_request_required_string_hostname_nullable_array", + Name: "TestRequestRequiredNumberNullableArray", + ID: "test_request_required_number_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringHostnameNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22470,15 +21603,15 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringHostnameNullableArray", - OperationID: "test_request_required_string_hostname_nullable_array", + OperationName: "TestRequestRequiredNumberNullableArray", + OperationID: "test_request_required_number_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []NilFloat64 Params = struct{} Response = Error ) @@ -22491,11 +21624,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringHostnameNullableArray(ctx, request) + return s.h.TestRequestRequiredNumberNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringHostnameNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -22503,23 +21636,23 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayRequest(arg return } - if err := encodeTestRequestRequiredStringHostnameNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringHostnameNullableArrayArrayRequest handles test_request_required_string_hostname_nullable_array_array operation. +// HandleTestRequestRequiredNumberNullableArrayArrayRequest handles test_request_required_number_nullable_array_array operation. // -// POST /test_request_required_string_hostname_nullable_array_array -func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_number_nullable_array_array +func (s *Server) handleTestRequestRequiredNumberNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_hostname_nullable_array_array"), + otelogen.OperationID("test_request_required_number_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredNumberNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22543,11 +21676,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayArrayReques } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringHostnameNullableArrayArray", - ID: "test_request_required_string_hostname_nullable_array_array", + Name: "TestRequestRequiredNumberNullableArrayArray", + ID: "test_request_required_number_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringHostnameNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredNumberNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22567,15 +21700,15 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayArrayReques if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringHostnameNullableArrayArray", - OperationID: "test_request_required_string_hostname_nullable_array_array", + OperationName: "TestRequestRequiredNumberNullableArrayArray", + OperationID: "test_request_required_number_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilFloat64 Params = struct{} Response = Error ) @@ -22588,11 +21721,11 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayArrayReques mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringHostnameNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredNumberNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringHostnameNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredNumberNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -22600,23 +21733,23 @@ func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayArrayReques return } - if err := encodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredNumberNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIPRequest handles test_request_required_string_ip operation. +// HandleTestRequestRequiredStringRequest handles test_request_required_string operation. // -// POST /test_request_required_string_ip -func (s *Server) handleTestRequestRequiredStringIPRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string +func (s *Server) handleTestRequestRequiredStringRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip"), + otelogen.OperationID("test_request_required_string"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIP", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredString", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22640,11 +21773,11 @@ func (s *Server) handleTestRequestRequiredStringIPRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIP", - ID: "test_request_required_string_ip", + Name: "TestRequestRequiredString", + ID: "test_request_required_string", } ) - request, close, err := s.decodeTestRequestRequiredStringIPRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22664,15 +21797,15 @@ func (s *Server) handleTestRequestRequiredStringIPRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIP", - OperationID: "test_request_required_string_ip", + OperationName: "TestRequestRequiredString", + OperationID: "test_request_required_string", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = netip.Addr + Request = string Params = struct{} Response = Error ) @@ -22685,11 +21818,11 @@ func (s *Server) handleTestRequestRequiredStringIPRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIP(ctx, request) + return s.h.TestRequestRequiredString(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIP(ctx, request) + response, err = s.h.TestRequestRequiredString(ctx, request) } if err != nil { recordError("Internal", err) @@ -22697,23 +21830,23 @@ func (s *Server) handleTestRequestRequiredStringIPRequest(args [0]string, w http return } - if err := encodeTestRequestRequiredStringIPResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIPArrayRequest handles test_request_required_string_ip_array operation. +// HandleTestRequestRequiredStringArrayRequest handles test_request_required_string_array operation. // -// POST /test_request_required_string_ip_array -func (s *Server) handleTestRequestRequiredStringIPArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_array +func (s *Server) handleTestRequestRequiredStringArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_array"), + otelogen.OperationID("test_request_required_string_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22737,11 +21870,11 @@ func (s *Server) handleTestRequestRequiredStringIPArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIPArray", - ID: "test_request_required_string_ip_array", + Name: "TestRequestRequiredStringArray", + ID: "test_request_required_string_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIPArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22761,15 +21894,15 @@ func (s *Server) handleTestRequestRequiredStringIPArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIPArray", - OperationID: "test_request_required_string_ip_array", + OperationName: "TestRequestRequiredStringArray", + OperationID: "test_request_required_string_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []netip.Addr + Request = []string Params = struct{} Response = Error ) @@ -22782,11 +21915,11 @@ func (s *Server) handleTestRequestRequiredStringIPArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIPArray(ctx, request) + return s.h.TestRequestRequiredStringArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIPArray(ctx, request) + response, err = s.h.TestRequestRequiredStringArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -22794,23 +21927,23 @@ func (s *Server) handleTestRequestRequiredStringIPArrayRequest(args [0]string, w return } - if err := encodeTestRequestRequiredStringIPArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIPArrayArrayRequest handles test_request_required_string_ip_array_array operation. +// HandleTestRequestRequiredStringArrayArrayRequest handles test_request_required_string_array_array operation. // -// POST /test_request_required_string_ip_array_array -func (s *Server) handleTestRequestRequiredStringIPArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_array_array +func (s *Server) handleTestRequestRequiredStringArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_array_array"), + otelogen.OperationID("test_request_required_string_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22834,11 +21967,11 @@ func (s *Server) handleTestRequestRequiredStringIPArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIPArrayArray", - ID: "test_request_required_string_ip_array_array", + Name: "TestRequestRequiredStringArrayArray", + ID: "test_request_required_string_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIPArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22858,15 +21991,15 @@ func (s *Server) handleTestRequestRequiredStringIPArrayArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIPArrayArray", - OperationID: "test_request_required_string_ip_array_array", + OperationName: "TestRequestRequiredStringArrayArray", + OperationID: "test_request_required_string_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]string Params = struct{} Response = Error ) @@ -22879,11 +22012,11 @@ func (s *Server) handleTestRequestRequiredStringIPArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIPArrayArray(ctx, request) + return s.h.TestRequestRequiredStringArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIPArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -22891,23 +22024,23 @@ func (s *Server) handleTestRequestRequiredStringIPArrayArrayRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringIPArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIPNullableRequest handles test_request_required_string_ip_nullable operation. +// HandleTestRequestRequiredStringBinaryRequest handles test_request_required_string_binary operation. // -// POST /test_request_required_string_ip_nullable -func (s *Server) handleTestRequestRequiredStringIPNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_binary +func (s *Server) handleTestRequestRequiredStringBinaryRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_nullable"), + otelogen.OperationID("test_request_required_string_binary"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinary", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -22931,11 +22064,11 @@ func (s *Server) handleTestRequestRequiredStringIPNullableRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIPNullable", - ID: "test_request_required_string_ip_nullable", + Name: "TestRequestRequiredStringBinary", + ID: "test_request_required_string_binary", } ) - request, close, err := s.decodeTestRequestRequiredStringIPNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringBinaryRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -22955,15 +22088,15 @@ func (s *Server) handleTestRequestRequiredStringIPNullableRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIPNullable", - OperationID: "test_request_required_string_ip_nullable", + OperationName: "TestRequestRequiredStringBinary", + OperationID: "test_request_required_string_binary", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilIP + Request = string Params = struct{} Response = Error ) @@ -22976,11 +22109,11 @@ func (s *Server) handleTestRequestRequiredStringIPNullableRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIPNullable(ctx, request) + return s.h.TestRequestRequiredStringBinary(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIPNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringBinary(ctx, request) } if err != nil { recordError("Internal", err) @@ -22988,23 +22121,23 @@ func (s *Server) handleTestRequestRequiredStringIPNullableRequest(args [0]string return } - if err := encodeTestRequestRequiredStringIPNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringBinaryResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIPNullableArrayRequest handles test_request_required_string_ip_nullable_array operation. +// HandleTestRequestRequiredStringBinaryArrayRequest handles test_request_required_string_binary_array operation. // -// POST /test_request_required_string_ip_nullable_array -func (s *Server) handleTestRequestRequiredStringIPNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_binary_array +func (s *Server) handleTestRequestRequiredStringBinaryArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_nullable_array"), + otelogen.OperationID("test_request_required_string_binary_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23028,11 +22161,11 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIPNullableArray", - ID: "test_request_required_string_ip_nullable_array", + Name: "TestRequestRequiredStringBinaryArray", + ID: "test_request_required_string_binary_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIPNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringBinaryArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23052,15 +22185,15 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIPNullableArray", - OperationID: "test_request_required_string_ip_nullable_array", + OperationName: "TestRequestRequiredStringBinaryArray", + OperationID: "test_request_required_string_binary_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilIP + Request = []string Params = struct{} Response = Error ) @@ -23073,11 +22206,11 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIPNullableArray(ctx, request) + return s.h.TestRequestRequiredStringBinaryArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIPNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringBinaryArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -23085,23 +22218,23 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredStringIPNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringBinaryArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIPNullableArrayArrayRequest handles test_request_required_string_ip_nullable_array_array operation. +// HandleTestRequestRequiredStringBinaryArrayArrayRequest handles test_request_required_string_binary_array_array operation. // -// POST /test_request_required_string_ip_nullable_array_array -func (s *Server) handleTestRequestRequiredStringIPNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_binary_array_array +func (s *Server) handleTestRequestRequiredStringBinaryArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ip_nullable_array_array"), + otelogen.OperationID("test_request_required_string_binary_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23125,11 +22258,11 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIPNullableArrayArray", - ID: "test_request_required_string_ip_nullable_array_array", + Name: "TestRequestRequiredStringBinaryArrayArray", + ID: "test_request_required_string_binary_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIPNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringBinaryArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23149,15 +22282,15 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIPNullableArrayArray", - OperationID: "test_request_required_string_ip_nullable_array_array", + OperationName: "TestRequestRequiredStringBinaryArrayArray", + OperationID: "test_request_required_string_binary_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilIP + Request = [][]string Params = struct{} Response = Error ) @@ -23170,11 +22303,11 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIPNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringBinaryArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIPNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringBinaryArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -23182,23 +22315,23 @@ func (s *Server) handleTestRequestRequiredStringIPNullableArrayArrayRequest(args return } - if err := encodeTestRequestRequiredStringIPNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringBinaryArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt32Request handles test_request_required_string_int32 operation. +// HandleTestRequestRequiredStringBinaryNullableRequest handles test_request_required_string_binary_nullable operation. // -// POST /test_request_required_string_int32 -func (s *Server) handleTestRequestRequiredStringInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_binary_nullable +func (s *Server) handleTestRequestRequiredStringBinaryNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32"), + otelogen.OperationID("test_request_required_string_binary_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23222,11 +22355,11 @@ func (s *Server) handleTestRequestRequiredStringInt32Request(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt32", - ID: "test_request_required_string_int32", + Name: "TestRequestRequiredStringBinaryNullable", + ID: "test_request_required_string_binary_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringInt32Request(r, span) + request, close, err := s.decodeTestRequestRequiredStringBinaryNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23246,15 +22379,15 @@ func (s *Server) handleTestRequestRequiredStringInt32Request(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt32", - OperationID: "test_request_required_string_int32", + OperationName: "TestRequestRequiredStringBinaryNullable", + OperationID: "test_request_required_string_binary_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = int32 + Request = NilString Params = struct{} Response = Error ) @@ -23267,11 +22400,11 @@ func (s *Server) handleTestRequestRequiredStringInt32Request(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt32(ctx, request) + return s.h.TestRequestRequiredStringBinaryNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt32(ctx, request) + response, err = s.h.TestRequestRequiredStringBinaryNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -23279,23 +22412,23 @@ func (s *Server) handleTestRequestRequiredStringInt32Request(args [0]string, w h return } - if err := encodeTestRequestRequiredStringInt32Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringBinaryNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt32ArrayRequest handles test_request_required_string_int32_array operation. +// HandleTestRequestRequiredStringBinaryNullableArrayRequest handles test_request_required_string_binary_nullable_array operation. // -// POST /test_request_required_string_int32_array -func (s *Server) handleTestRequestRequiredStringInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_binary_nullable_array +func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_array"), + otelogen.OperationID("test_request_required_string_binary_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23319,11 +22452,11 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt32Array", - ID: "test_request_required_string_int32_array", + Name: "TestRequestRequiredStringBinaryNullableArray", + ID: "test_request_required_string_binary_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt32ArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringBinaryNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23343,15 +22476,15 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt32Array", - OperationID: "test_request_required_string_int32_array", + OperationName: "TestRequestRequiredStringBinaryNullableArray", + OperationID: "test_request_required_string_binary_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int32 + Request = []NilString Params = struct{} Response = Error ) @@ -23364,11 +22497,11 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt32Array(ctx, request) + return s.h.TestRequestRequiredStringBinaryNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt32Array(ctx, request) + response, err = s.h.TestRequestRequiredStringBinaryNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -23376,23 +22509,23 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredStringInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringBinaryNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt32ArrayArrayRequest handles test_request_required_string_int32_array_array operation. +// HandleTestRequestRequiredStringBinaryNullableArrayArrayRequest handles test_request_required_string_binary_nullable_array_array operation. // -// POST /test_request_required_string_int32_array_array -func (s *Server) handleTestRequestRequiredStringInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_binary_nullable_array_array +func (s *Server) handleTestRequestRequiredStringBinaryNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_array_array"), + otelogen.OperationID("test_request_required_string_binary_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringBinaryNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23416,11 +22549,11 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt32ArrayArray", - ID: "test_request_required_string_int32_array_array", + Name: "TestRequestRequiredStringBinaryNullableArrayArray", + ID: "test_request_required_string_binary_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt32ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23440,15 +22573,15 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt32ArrayArray", - OperationID: "test_request_required_string_int32_array_array", + OperationName: "TestRequestRequiredStringBinaryNullableArrayArray", + OperationID: "test_request_required_string_binary_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int32 + Request = [][]NilString Params = struct{} Response = Error ) @@ -23461,11 +22594,11 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt32ArrayArray(ctx, request) + return s.h.TestRequestRequiredStringBinaryNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt32ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringBinaryNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -23473,23 +22606,23 @@ func (s *Server) handleTestRequestRequiredStringInt32ArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredStringInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt32NullableRequest handles test_request_required_string_int32_nullable operation. +// HandleTestRequestRequiredStringByteRequest handles test_request_required_string_byte operation. // -// POST /test_request_required_string_int32_nullable -func (s *Server) handleTestRequestRequiredStringInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_byte +func (s *Server) handleTestRequestRequiredStringByteRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_nullable"), + otelogen.OperationID("test_request_required_string_byte"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByte", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23513,11 +22646,11 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt32Nullable", - ID: "test_request_required_string_int32_nullable", + Name: "TestRequestRequiredStringByte", + ID: "test_request_required_string_byte", } ) - request, close, err := s.decodeTestRequestRequiredStringInt32NullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringByteRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23537,15 +22670,15 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt32Nullable", - OperationID: "test_request_required_string_int32_nullable", + OperationName: "TestRequestRequiredStringByte", + OperationID: "test_request_required_string_byte", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilStringInt32 + Request = []byte Params = struct{} Response = Error ) @@ -23558,11 +22691,11 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt32Nullable(ctx, request) + return s.h.TestRequestRequiredStringByte(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt32Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringByte(ctx, request) } if err != nil { recordError("Internal", err) @@ -23570,23 +22703,23 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableRequest(args [0]str return } - if err := encodeTestRequestRequiredStringInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringByteResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt32NullableArrayRequest handles test_request_required_string_int32_nullable_array operation. +// HandleTestRequestRequiredStringByteArrayRequest handles test_request_required_string_byte_array operation. // -// POST /test_request_required_string_int32_nullable_array -func (s *Server) handleTestRequestRequiredStringInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_byte_array +func (s *Server) handleTestRequestRequiredStringByteArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_nullable_array"), + otelogen.OperationID("test_request_required_string_byte_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23610,11 +22743,11 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt32NullableArray", - ID: "test_request_required_string_int32_nullable_array", + Name: "TestRequestRequiredStringByteArray", + ID: "test_request_required_string_byte_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt32NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringByteArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23634,15 +22767,15 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt32NullableArray", - OperationID: "test_request_required_string_int32_nullable_array", + OperationName: "TestRequestRequiredStringByteArray", + OperationID: "test_request_required_string_byte_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringInt32 + Request = [][]byte Params = struct{} Response = Error ) @@ -23655,11 +22788,11 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt32NullableArray(ctx, request) + return s.h.TestRequestRequiredStringByteArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt32NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringByteArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -23667,23 +22800,23 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringByteArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt32NullableArrayArrayRequest handles test_request_required_string_int32_nullable_array_array operation. +// HandleTestRequestRequiredStringByteArrayArrayRequest handles test_request_required_string_byte_array_array operation. // -// POST /test_request_required_string_int32_nullable_array_array -func (s *Server) handleTestRequestRequiredStringInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_byte_array_array +func (s *Server) handleTestRequestRequiredStringByteArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int32_nullable_array_array"), + otelogen.OperationID("test_request_required_string_byte_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23707,11 +22840,11 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt32NullableArrayArray", - ID: "test_request_required_string_int32_nullable_array_array", + Name: "TestRequestRequiredStringByteArrayArray", + ID: "test_request_required_string_byte_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt32NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringByteArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23731,15 +22864,15 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt32NullableArrayArray", - OperationID: "test_request_required_string_int32_nullable_array_array", + OperationName: "TestRequestRequiredStringByteArrayArray", + OperationID: "test_request_required_string_byte_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringInt32 + Request = [][][]byte Params = struct{} Response = Error ) @@ -23752,11 +22885,11 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt32NullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringByteArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringByteArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -23764,23 +22897,23 @@ func (s *Server) handleTestRequestRequiredStringInt32NullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredStringInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringByteArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt64Request handles test_request_required_string_int64 operation. +// HandleTestRequestRequiredStringByteNullableRequest handles test_request_required_string_byte_nullable operation. // -// POST /test_request_required_string_int64 -func (s *Server) handleTestRequestRequiredStringInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_byte_nullable +func (s *Server) handleTestRequestRequiredStringByteNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64"), + otelogen.OperationID("test_request_required_string_byte_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23804,11 +22937,11 @@ func (s *Server) handleTestRequestRequiredStringInt64Request(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt64", - ID: "test_request_required_string_int64", + Name: "TestRequestRequiredStringByteNullable", + ID: "test_request_required_string_byte_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringInt64Request(r, span) + request, close, err := s.decodeTestRequestRequiredStringByteNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23828,15 +22961,15 @@ func (s *Server) handleTestRequestRequiredStringInt64Request(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt64", - OperationID: "test_request_required_string_int64", + OperationName: "TestRequestRequiredStringByteNullable", + OperationID: "test_request_required_string_byte_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = int64 + Request = []byte Params = struct{} Response = Error ) @@ -23849,11 +22982,11 @@ func (s *Server) handleTestRequestRequiredStringInt64Request(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt64(ctx, request) + return s.h.TestRequestRequiredStringByteNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt64(ctx, request) + response, err = s.h.TestRequestRequiredStringByteNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -23861,23 +22994,23 @@ func (s *Server) handleTestRequestRequiredStringInt64Request(args [0]string, w h return } - if err := encodeTestRequestRequiredStringInt64Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringByteNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt64ArrayRequest handles test_request_required_string_int64_array operation. +// HandleTestRequestRequiredStringByteNullableArrayRequest handles test_request_required_string_byte_nullable_array operation. // -// POST /test_request_required_string_int64_array -func (s *Server) handleTestRequestRequiredStringInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_byte_nullable_array +func (s *Server) handleTestRequestRequiredStringByteNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_array"), + otelogen.OperationID("test_request_required_string_byte_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23901,11 +23034,11 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt64Array", - ID: "test_request_required_string_int64_array", + Name: "TestRequestRequiredStringByteNullableArray", + ID: "test_request_required_string_byte_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt64ArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringByteNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -23925,15 +23058,15 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt64Array", - OperationID: "test_request_required_string_int64_array", + OperationName: "TestRequestRequiredStringByteNullableArray", + OperationID: "test_request_required_string_byte_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int64 + Request = [][]byte Params = struct{} Response = Error ) @@ -23946,11 +23079,11 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt64Array(ctx, request) + return s.h.TestRequestRequiredStringByteNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt64Array(ctx, request) + response, err = s.h.TestRequestRequiredStringByteNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -23958,23 +23091,23 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredStringInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringByteNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt64ArrayArrayRequest handles test_request_required_string_int64_array_array operation. +// HandleTestRequestRequiredStringByteNullableArrayArrayRequest handles test_request_required_string_byte_nullable_array_array operation. // -// POST /test_request_required_string_int64_array_array -func (s *Server) handleTestRequestRequiredStringInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_byte_nullable_array_array +func (s *Server) handleTestRequestRequiredStringByteNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_array_array"), + otelogen.OperationID("test_request_required_string_byte_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringByteNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -23998,11 +23131,11 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt64ArrayArray", - ID: "test_request_required_string_int64_array_array", + Name: "TestRequestRequiredStringByteNullableArrayArray", + ID: "test_request_required_string_byte_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt64ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringByteNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24022,15 +23155,15 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt64ArrayArray", - OperationID: "test_request_required_string_int64_array_array", + OperationName: "TestRequestRequiredStringByteNullableArrayArray", + OperationID: "test_request_required_string_byte_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int64 + Request = [][][]byte Params = struct{} Response = Error ) @@ -24043,11 +23176,11 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt64ArrayArray(ctx, request) + return s.h.TestRequestRequiredStringByteNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt64ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringByteNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -24055,23 +23188,23 @@ func (s *Server) handleTestRequestRequiredStringInt64ArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredStringInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringByteNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt64NullableRequest handles test_request_required_string_int64_nullable operation. +// HandleTestRequestRequiredStringDateRequest handles test_request_required_string_date operation. // -// POST /test_request_required_string_int64_nullable -func (s *Server) handleTestRequestRequiredStringInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date +func (s *Server) handleTestRequestRequiredStringDateRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_nullable"), + otelogen.OperationID("test_request_required_string_date"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDate", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24095,11 +23228,11 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt64Nullable", - ID: "test_request_required_string_int64_nullable", + Name: "TestRequestRequiredStringDate", + ID: "test_request_required_string_date", } ) - request, close, err := s.decodeTestRequestRequiredStringInt64NullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24119,15 +23252,15 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt64Nullable", - OperationID: "test_request_required_string_int64_nullable", + OperationName: "TestRequestRequiredStringDate", + OperationID: "test_request_required_string_date", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilStringInt64 + Request = time.Time Params = struct{} Response = Error ) @@ -24140,11 +23273,11 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt64Nullable(ctx, request) + return s.h.TestRequestRequiredStringDate(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt64Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringDate(ctx, request) } if err != nil { recordError("Internal", err) @@ -24152,23 +23285,23 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableRequest(args [0]str return } - if err := encodeTestRequestRequiredStringInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt64NullableArrayRequest handles test_request_required_string_int64_nullable_array operation. +// HandleTestRequestRequiredStringDateArrayRequest handles test_request_required_string_date_array operation. // -// POST /test_request_required_string_int64_nullable_array -func (s *Server) handleTestRequestRequiredStringInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date_array +func (s *Server) handleTestRequestRequiredStringDateArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_nullable_array"), + otelogen.OperationID("test_request_required_string_date_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24192,11 +23325,11 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt64NullableArray", - ID: "test_request_required_string_int64_nullable_array", + Name: "TestRequestRequiredStringDateArray", + ID: "test_request_required_string_date_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt64NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24216,15 +23349,15 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt64NullableArray", - OperationID: "test_request_required_string_int64_nullable_array", + OperationName: "TestRequestRequiredStringDateArray", + OperationID: "test_request_required_string_date_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringInt64 + Request = []time.Time Params = struct{} Response = Error ) @@ -24237,11 +23370,11 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt64NullableArray(ctx, request) + return s.h.TestRequestRequiredStringDateArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt64NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDateArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -24249,23 +23382,23 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringInt64NullableArrayArrayRequest handles test_request_required_string_int64_nullable_array_array operation. +// HandleTestRequestRequiredStringDateArrayArrayRequest handles test_request_required_string_date_array_array operation. // -// POST /test_request_required_string_int64_nullable_array_array -func (s *Server) handleTestRequestRequiredStringInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date_array_array +func (s *Server) handleTestRequestRequiredStringDateArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_int64_nullable_array_array"), + otelogen.OperationID("test_request_required_string_date_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24289,11 +23422,11 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringInt64NullableArrayArray", - ID: "test_request_required_string_int64_nullable_array_array", + Name: "TestRequestRequiredStringDateArrayArray", + ID: "test_request_required_string_date_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24313,15 +23446,15 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringInt64NullableArrayArray", - OperationID: "test_request_required_string_int64_nullable_array_array", + OperationName: "TestRequestRequiredStringDateArrayArray", + OperationID: "test_request_required_string_date_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringInt64 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -24334,11 +23467,11 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringInt64NullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringDateArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringInt64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDateArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -24346,23 +23479,23 @@ func (s *Server) handleTestRequestRequiredStringInt64NullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredStringInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv4Request handles test_request_required_string_ipv4 operation. +// HandleTestRequestRequiredStringDateNullableRequest handles test_request_required_string_date_nullable operation. // -// POST /test_request_required_string_ipv4 -func (s *Server) handleTestRequestRequiredStringIpv4Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date_nullable +func (s *Server) handleTestRequestRequiredStringDateNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4"), + otelogen.OperationID("test_request_required_string_date_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24386,11 +23519,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4Request(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv4", - ID: "test_request_required_string_ipv4", + Name: "TestRequestRequiredStringDateNullable", + ID: "test_request_required_string_date_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv4Request(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24410,15 +23543,15 @@ func (s *Server) handleTestRequestRequiredStringIpv4Request(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv4", - OperationID: "test_request_required_string_ipv4", + OperationName: "TestRequestRequiredStringDateNullable", + OperationID: "test_request_required_string_date_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = netip.Addr + Request = NilDate Params = struct{} Response = Error ) @@ -24431,11 +23564,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4Request(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv4(ctx, request) + return s.h.TestRequestRequiredStringDateNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv4(ctx, request) + response, err = s.h.TestRequestRequiredStringDateNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -24443,23 +23576,23 @@ func (s *Server) handleTestRequestRequiredStringIpv4Request(args [0]string, w ht return } - if err := encodeTestRequestRequiredStringIpv4Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv4ArrayRequest handles test_request_required_string_ipv4_array operation. +// HandleTestRequestRequiredStringDateNullableArrayRequest handles test_request_required_string_date_nullable_array operation. // -// POST /test_request_required_string_ipv4_array -func (s *Server) handleTestRequestRequiredStringIpv4ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date_nullable_array +func (s *Server) handleTestRequestRequiredStringDateNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_array"), + otelogen.OperationID("test_request_required_string_date_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24483,11 +23616,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv4Array", - ID: "test_request_required_string_ipv4_array", + Name: "TestRequestRequiredStringDateNullableArray", + ID: "test_request_required_string_date_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv4ArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24507,15 +23640,15 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv4Array", - OperationID: "test_request_required_string_ipv4_array", + OperationName: "TestRequestRequiredStringDateNullableArray", + OperationID: "test_request_required_string_date_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []netip.Addr + Request = []NilDate Params = struct{} Response = Error ) @@ -24528,11 +23661,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv4Array(ctx, request) + return s.h.TestRequestRequiredStringDateNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv4Array(ctx, request) + response, err = s.h.TestRequestRequiredStringDateNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -24540,23 +23673,23 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringIpv4ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv4ArrayArrayRequest handles test_request_required_string_ipv4_array_array operation. +// HandleTestRequestRequiredStringDateNullableArrayArrayRequest handles test_request_required_string_date_nullable_array_array operation. // -// POST /test_request_required_string_ipv4_array_array -func (s *Server) handleTestRequestRequiredStringIpv4ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date_nullable_array_array +func (s *Server) handleTestRequestRequiredStringDateNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_array_array"), + otelogen.OperationID("test_request_required_string_date_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24580,11 +23713,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv4ArrayArray", - ID: "test_request_required_string_ipv4_array_array", + Name: "TestRequestRequiredStringDateNullableArrayArray", + ID: "test_request_required_string_date_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24604,15 +23737,15 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv4ArrayArray", - OperationID: "test_request_required_string_ipv4_array_array", + OperationName: "TestRequestRequiredStringDateNullableArrayArray", + OperationID: "test_request_required_string_date_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]NilDate Params = struct{} Response = Error ) @@ -24625,11 +23758,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv4ArrayArray(ctx, request) + return s.h.TestRequestRequiredStringDateNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv4ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDateNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -24637,23 +23770,23 @@ func (s *Server) handleTestRequestRequiredStringIpv4ArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringIpv4ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv4NullableRequest handles test_request_required_string_ipv4_nullable operation. +// HandleTestRequestRequiredStringDateTimeRequest handles test_request_required_string_date-time operation. // -// POST /test_request_required_string_ipv4_nullable -func (s *Server) handleTestRequestRequiredStringIpv4NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date-time +func (s *Server) handleTestRequestRequiredStringDateTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_nullable"), + otelogen.OperationID("test_request_required_string_date-time"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTime", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24677,11 +23810,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv4Nullable", - ID: "test_request_required_string_ipv4_nullable", + Name: "TestRequestRequiredStringDateTime", + ID: "test_request_required_string_date-time", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv4NullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateTimeRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24701,15 +23834,15 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv4Nullable", - OperationID: "test_request_required_string_ipv4_nullable", + OperationName: "TestRequestRequiredStringDateTime", + OperationID: "test_request_required_string_date-time", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilIPv4 + Request = time.Time Params = struct{} Response = Error ) @@ -24722,11 +23855,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv4Nullable(ctx, request) + return s.h.TestRequestRequiredStringDateTime(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv4Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringDateTime(ctx, request) } if err != nil { recordError("Internal", err) @@ -24734,23 +23867,23 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringIpv4NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateTimeResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv4NullableArrayRequest handles test_request_required_string_ipv4_nullable_array operation. +// HandleTestRequestRequiredStringDateTimeArrayRequest handles test_request_required_string_date-time_array operation. // -// POST /test_request_required_string_ipv4_nullable_array -func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date-time_array +func (s *Server) handleTestRequestRequiredStringDateTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_nullable_array"), + otelogen.OperationID("test_request_required_string_date-time_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24774,11 +23907,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv4NullableArray", - ID: "test_request_required_string_ipv4_nullable_array", + Name: "TestRequestRequiredStringDateTimeArray", + ID: "test_request_required_string_date-time_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv4NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateTimeArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24798,15 +23931,15 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv4NullableArray", - OperationID: "test_request_required_string_ipv4_nullable_array", + OperationName: "TestRequestRequiredStringDateTimeArray", + OperationID: "test_request_required_string_date-time_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilIPv4 + Request = []time.Time Params = struct{} Response = Error ) @@ -24819,11 +23952,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv4NullableArray(ctx, request) + return s.h.TestRequestRequiredStringDateTimeArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv4NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDateTimeArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -24831,23 +23964,23 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringIpv4NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateTimeArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv4NullableArrayArrayRequest handles test_request_required_string_ipv4_nullable_array_array operation. +// HandleTestRequestRequiredStringDateTimeArrayArrayRequest handles test_request_required_string_date-time_array_array operation. // -// POST /test_request_required_string_ipv4_nullable_array_array -func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date-time_array_array +func (s *Server) handleTestRequestRequiredStringDateTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv4_nullable_array_array"), + otelogen.OperationID("test_request_required_string_date-time_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24871,11 +24004,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv4NullableArrayArray", - ID: "test_request_required_string_ipv4_nullable_array_array", + Name: "TestRequestRequiredStringDateTimeArrayArray", + ID: "test_request_required_string_date-time_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24895,15 +24028,15 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv4NullableArrayArray", - OperationID: "test_request_required_string_ipv4_nullable_array_array", + OperationName: "TestRequestRequiredStringDateTimeArrayArray", + OperationID: "test_request_required_string_date-time_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilIPv4 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -24916,11 +24049,11 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv4NullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringDateTimeArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv4NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDateTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -24928,23 +24061,23 @@ func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv6Request handles test_request_required_string_ipv6 operation. +// HandleTestRequestRequiredStringDateTimeNullableRequest handles test_request_required_string_date-time_nullable operation. // -// POST /test_request_required_string_ipv6 -func (s *Server) handleTestRequestRequiredStringIpv6Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date-time_nullable +func (s *Server) handleTestRequestRequiredStringDateTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6"), + otelogen.OperationID("test_request_required_string_date-time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -24968,11 +24101,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6Request(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv6", - ID: "test_request_required_string_ipv6", + Name: "TestRequestRequiredStringDateTimeNullable", + ID: "test_request_required_string_date-time_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv6Request(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateTimeNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -24992,15 +24125,15 @@ func (s *Server) handleTestRequestRequiredStringIpv6Request(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv6", - OperationID: "test_request_required_string_ipv6", + OperationName: "TestRequestRequiredStringDateTimeNullable", + OperationID: "test_request_required_string_date-time_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = netip.Addr + Request = NilDateTime Params = struct{} Response = Error ) @@ -25013,11 +24146,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6Request(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv6(ctx, request) + return s.h.TestRequestRequiredStringDateTimeNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv6(ctx, request) + response, err = s.h.TestRequestRequiredStringDateTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -25025,23 +24158,23 @@ func (s *Server) handleTestRequestRequiredStringIpv6Request(args [0]string, w ht return } - if err := encodeTestRequestRequiredStringIpv6Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv6ArrayRequest handles test_request_required_string_ipv6_array operation. +// HandleTestRequestRequiredStringDateTimeNullableArrayRequest handles test_request_required_string_date-time_nullable_array operation. // -// POST /test_request_required_string_ipv6_array -func (s *Server) handleTestRequestRequiredStringIpv6ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date-time_nullable_array +func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_array"), + otelogen.OperationID("test_request_required_string_date-time_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25065,11 +24198,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv6Array", - ID: "test_request_required_string_ipv6_array", + Name: "TestRequestRequiredStringDateTimeNullableArray", + ID: "test_request_required_string_date-time_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv6ArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateTimeNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25089,15 +24222,15 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv6Array", - OperationID: "test_request_required_string_ipv6_array", + OperationName: "TestRequestRequiredStringDateTimeNullableArray", + OperationID: "test_request_required_string_date-time_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []netip.Addr + Request = []NilDateTime Params = struct{} Response = Error ) @@ -25110,11 +24243,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv6Array(ctx, request) + return s.h.TestRequestRequiredStringDateTimeNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv6Array(ctx, request) + response, err = s.h.TestRequestRequiredStringDateTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -25122,23 +24255,23 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringIpv6ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv6ArrayArrayRequest handles test_request_required_string_ipv6_array_array operation. +// HandleTestRequestRequiredStringDateTimeNullableArrayArrayRequest handles test_request_required_string_date-time_nullable_array_array operation. // -// POST /test_request_required_string_ipv6_array_array -func (s *Server) handleTestRequestRequiredStringIpv6ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_date-time_nullable_array_array +func (s *Server) handleTestRequestRequiredStringDateTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_array_array"), + otelogen.OperationID("test_request_required_string_date-time_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDateTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25162,11 +24295,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv6ArrayArray", - ID: "test_request_required_string_ipv6_array_array", + Name: "TestRequestRequiredStringDateTimeNullableArrayArray", + ID: "test_request_required_string_date-time_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv6ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDateTimeNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25186,15 +24319,15 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv6ArrayArray", - OperationID: "test_request_required_string_ipv6_array_array", + OperationName: "TestRequestRequiredStringDateTimeNullableArrayArray", + OperationID: "test_request_required_string_date-time_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]NilDateTime Params = struct{} Response = Error ) @@ -25207,11 +24340,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv6ArrayArray(ctx, request) + return s.h.TestRequestRequiredStringDateTimeNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv6ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDateTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -25219,23 +24352,23 @@ func (s *Server) handleTestRequestRequiredStringIpv6ArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringIpv6ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv6NullableRequest handles test_request_required_string_ipv6_nullable operation. +// HandleTestRequestRequiredStringDurationRequest handles test_request_required_string_duration operation. // -// POST /test_request_required_string_ipv6_nullable -func (s *Server) handleTestRequestRequiredStringIpv6NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_duration +func (s *Server) handleTestRequestRequiredStringDurationRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_nullable"), + otelogen.OperationID("test_request_required_string_duration"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDuration", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25259,11 +24392,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv6Nullable", - ID: "test_request_required_string_ipv6_nullable", + Name: "TestRequestRequiredStringDuration", + ID: "test_request_required_string_duration", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv6NullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDurationRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25283,15 +24416,15 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv6Nullable", - OperationID: "test_request_required_string_ipv6_nullable", + OperationName: "TestRequestRequiredStringDuration", + OperationID: "test_request_required_string_duration", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilIPv6 + Request = time.Duration Params = struct{} Response = Error ) @@ -25304,11 +24437,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv6Nullable(ctx, request) + return s.h.TestRequestRequiredStringDuration(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv6Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringDuration(ctx, request) } if err != nil { recordError("Internal", err) @@ -25316,23 +24449,23 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringIpv6NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDurationResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv6NullableArrayRequest handles test_request_required_string_ipv6_nullable_array operation. +// HandleTestRequestRequiredStringDurationArrayRequest handles test_request_required_string_duration_array operation. // -// POST /test_request_required_string_ipv6_nullable_array -func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_duration_array +func (s *Server) handleTestRequestRequiredStringDurationArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_nullable_array"), + otelogen.OperationID("test_request_required_string_duration_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25356,11 +24489,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv6NullableArray", - ID: "test_request_required_string_ipv6_nullable_array", + Name: "TestRequestRequiredStringDurationArray", + ID: "test_request_required_string_duration_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv6NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDurationArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25380,15 +24513,15 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv6NullableArray", - OperationID: "test_request_required_string_ipv6_nullable_array", + OperationName: "TestRequestRequiredStringDurationArray", + OperationID: "test_request_required_string_duration_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilIPv6 + Request = []time.Duration Params = struct{} Response = Error ) @@ -25401,11 +24534,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv6NullableArray(ctx, request) + return s.h.TestRequestRequiredStringDurationArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv6NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDurationArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -25413,23 +24546,23 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringIpv6NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDurationArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringIpv6NullableArrayArrayRequest handles test_request_required_string_ipv6_nullable_array_array operation. +// HandleTestRequestRequiredStringDurationArrayArrayRequest handles test_request_required_string_duration_array_array operation. // -// POST /test_request_required_string_ipv6_nullable_array_array -func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_duration_array_array +func (s *Server) handleTestRequestRequiredStringDurationArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_ipv6_nullable_array_array"), + otelogen.OperationID("test_request_required_string_duration_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25453,11 +24586,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringIpv6NullableArrayArray", - ID: "test_request_required_string_ipv6_nullable_array_array", + Name: "TestRequestRequiredStringDurationArrayArray", + ID: "test_request_required_string_duration_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDurationArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25477,15 +24610,15 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringIpv6NullableArrayArray", - OperationID: "test_request_required_string_ipv6_nullable_array_array", + OperationName: "TestRequestRequiredStringDurationArrayArray", + OperationID: "test_request_required_string_duration_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilIPv6 + Request = [][]time.Duration Params = struct{} Response = Error ) @@ -25498,11 +24631,11 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringIpv6NullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringDurationArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringIpv6NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDurationArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -25510,23 +24643,23 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDurationArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringNullableRequest handles test_request_required_string_nullable operation. +// HandleTestRequestRequiredStringDurationNullableRequest handles test_request_required_string_duration_nullable operation. // -// POST /test_request_required_string_nullable -func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_duration_nullable +func (s *Server) handleTestRequestRequiredStringDurationNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable"), + otelogen.OperationID("test_request_required_string_duration_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25550,11 +24683,11 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringNullable", - ID: "test_request_required_string_nullable", + Name: "TestRequestRequiredStringDurationNullable", + ID: "test_request_required_string_duration_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDurationNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25574,15 +24707,15 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringNullable", - OperationID: "test_request_required_string_nullable", + OperationName: "TestRequestRequiredStringDurationNullable", + OperationID: "test_request_required_string_duration_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilString + Request = NilDuration Params = struct{} Response = Error ) @@ -25595,11 +24728,11 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringNullable(ctx, request) + return s.h.TestRequestRequiredStringDurationNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringDurationNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -25607,23 +24740,23 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDurationNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringNullableArrayRequest handles test_request_required_string_nullable_array operation. +// HandleTestRequestRequiredStringDurationNullableArrayRequest handles test_request_required_string_duration_nullable_array operation. // -// POST /test_request_required_string_nullable_array -func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_duration_nullable_array +func (s *Server) handleTestRequestRequiredStringDurationNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable_array"), + otelogen.OperationID("test_request_required_string_duration_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25647,11 +24780,11 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringNullableArray", - ID: "test_request_required_string_nullable_array", + Name: "TestRequestRequiredStringDurationNullableArray", + ID: "test_request_required_string_duration_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDurationNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25671,15 +24804,15 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringNullableArray", - OperationID: "test_request_required_string_nullable_array", + OperationName: "TestRequestRequiredStringDurationNullableArray", + OperationID: "test_request_required_string_duration_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []NilDuration Params = struct{} Response = Error ) @@ -25692,11 +24825,11 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringNullableArray(ctx, request) + return s.h.TestRequestRequiredStringDurationNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDurationNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -25704,23 +24837,23 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDurationNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringNullableArrayArrayRequest handles test_request_required_string_nullable_array_array operation. +// HandleTestRequestRequiredStringDurationNullableArrayArrayRequest handles test_request_required_string_duration_nullable_array_array operation. // -// POST /test_request_required_string_nullable_array_array -func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_duration_nullable_array_array +func (s *Server) handleTestRequestRequiredStringDurationNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable_array_array"), + otelogen.OperationID("test_request_required_string_duration_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringDurationNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25744,11 +24877,11 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringNullableArrayArray", - ID: "test_request_required_string_nullable_array_array", + Name: "TestRequestRequiredStringDurationNullableArrayArray", + ID: "test_request_required_string_duration_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringDurationNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25768,15 +24901,15 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringNullableArrayArray", - OperationID: "test_request_required_string_nullable_array_array", + OperationName: "TestRequestRequiredStringDurationNullableArrayArray", + OperationID: "test_request_required_string_duration_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilDuration Params = struct{} Response = Error ) @@ -25789,11 +24922,11 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringDurationNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringDurationNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -25801,23 +24934,23 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringDurationNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringPasswordRequest handles test_request_required_string_password operation. +// HandleTestRequestRequiredStringEmailRequest handles test_request_required_string_email operation. // -// POST /test_request_required_string_password -func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_email +func (s *Server) handleTestRequestRequiredStringEmailRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password"), + otelogen.OperationID("test_request_required_string_email"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPassword", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmail", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25841,11 +24974,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPassword", - ID: "test_request_required_string_password", + Name: "TestRequestRequiredStringEmail", + ID: "test_request_required_string_email", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringEmailRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25865,8 +24998,8 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPassword", - OperationID: "test_request_required_string_password", + OperationName: "TestRequestRequiredStringEmail", + OperationID: "test_request_required_string_email", Body: request, Params: map[string]any{}, Raw: r, @@ -25886,11 +25019,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringPassword(ctx, request) + return s.h.TestRequestRequiredStringEmail(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringPassword(ctx, request) + response, err = s.h.TestRequestRequiredStringEmail(ctx, request) } if err != nil { recordError("Internal", err) @@ -25898,23 +25031,23 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringPasswordResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringEmailResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringPasswordArrayRequest handles test_request_required_string_password_array operation. +// HandleTestRequestRequiredStringEmailArrayRequest handles test_request_required_string_email_array operation. // -// POST /test_request_required_string_password_array -func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_email_array +func (s *Server) handleTestRequestRequiredStringEmailArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_array"), + otelogen.OperationID("test_request_required_string_email_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -25938,11 +25071,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordArray", - ID: "test_request_required_string_password_array", + Name: "TestRequestRequiredStringEmailArray", + ID: "test_request_required_string_email_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringEmailArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -25962,8 +25095,8 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordArray", - OperationID: "test_request_required_string_password_array", + OperationName: "TestRequestRequiredStringEmailArray", + OperationID: "test_request_required_string_email_array", Body: request, Params: map[string]any{}, Raw: r, @@ -25983,11 +25116,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringPasswordArray(ctx, request) + return s.h.TestRequestRequiredStringEmailArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordArray(ctx, request) + response, err = s.h.TestRequestRequiredStringEmailArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -25995,23 +25128,23 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringPasswordArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringEmailArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringPasswordArrayArrayRequest handles test_request_required_string_password_array_array operation. +// HandleTestRequestRequiredStringEmailArrayArrayRequest handles test_request_required_string_email_array_array operation. // -// POST /test_request_required_string_password_array_array -func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_email_array_array +func (s *Server) handleTestRequestRequiredStringEmailArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_array_array"), + otelogen.OperationID("test_request_required_string_email_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26035,11 +25168,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordArrayArray", - ID: "test_request_required_string_password_array_array", + Name: "TestRequestRequiredStringEmailArrayArray", + ID: "test_request_required_string_email_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringEmailArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26059,8 +25192,8 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordArrayArray", - OperationID: "test_request_required_string_password_array_array", + OperationName: "TestRequestRequiredStringEmailArrayArray", + OperationID: "test_request_required_string_email_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -26080,11 +25213,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) + return s.h.TestRequestRequiredStringEmailArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringEmailArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -26092,23 +25225,23 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringPasswordArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringEmailArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringPasswordNullableRequest handles test_request_required_string_password_nullable operation. +// HandleTestRequestRequiredStringEmailNullableRequest handles test_request_required_string_email_nullable operation. // -// POST /test_request_required_string_password_nullable -func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_email_nullable +func (s *Server) handleTestRequestRequiredStringEmailNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable"), + otelogen.OperationID("test_request_required_string_email_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26132,11 +25265,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordNullable", - ID: "test_request_required_string_password_nullable", + Name: "TestRequestRequiredStringEmailNullable", + ID: "test_request_required_string_email_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringEmailNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26156,8 +25289,8 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordNullable", - OperationID: "test_request_required_string_password_nullable", + OperationName: "TestRequestRequiredStringEmailNullable", + OperationID: "test_request_required_string_email_nullable", Body: request, Params: map[string]any{}, Raw: r, @@ -26177,11 +25310,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringPasswordNullable(ctx, request) + return s.h.TestRequestRequiredStringEmailNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringEmailNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -26189,23 +25322,23 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] return } - if err := encodeTestRequestRequiredStringPasswordNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringEmailNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringPasswordNullableArrayRequest handles test_request_required_string_password_nullable_array operation. +// HandleTestRequestRequiredStringEmailNullableArrayRequest handles test_request_required_string_email_nullable_array operation. // -// POST /test_request_required_string_password_nullable_array -func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_email_nullable_array +func (s *Server) handleTestRequestRequiredStringEmailNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable_array"), + otelogen.OperationID("test_request_required_string_email_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26229,11 +25362,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordNullableArray", - ID: "test_request_required_string_password_nullable_array", + Name: "TestRequestRequiredStringEmailNullableArray", + ID: "test_request_required_string_email_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringEmailNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26253,8 +25386,8 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordNullableArray", - OperationID: "test_request_required_string_password_nullable_array", + OperationName: "TestRequestRequiredStringEmailNullableArray", + OperationID: "test_request_required_string_email_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -26274,11 +25407,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) + return s.h.TestRequestRequiredStringEmailNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringEmailNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -26286,23 +25419,23 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg return } - if err := encodeTestRequestRequiredStringPasswordNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringEmailNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringPasswordNullableArrayArrayRequest handles test_request_required_string_password_nullable_array_array operation. +// HandleTestRequestRequiredStringEmailNullableArrayArrayRequest handles test_request_required_string_email_nullable_array_array operation. // -// POST /test_request_required_string_password_nullable_array_array -func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_email_nullable_array_array +func (s *Server) handleTestRequestRequiredStringEmailNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable_array_array"), + otelogen.OperationID("test_request_required_string_email_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringEmailNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26326,11 +25459,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordNullableArrayArray", - ID: "test_request_required_string_password_nullable_array_array", + Name: "TestRequestRequiredStringEmailNullableArrayArray", + ID: "test_request_required_string_email_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26350,8 +25483,8 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordNullableArrayArray", - OperationID: "test_request_required_string_password_nullable_array_array", + OperationName: "TestRequestRequiredStringEmailNullableArrayArray", + OperationID: "test_request_required_string_email_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -26371,11 +25504,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringEmailNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringEmailNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -26383,23 +25516,23 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques return } - if err := encodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringEmailNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringTimeRequest handles test_request_required_string_time operation. +// HandleTestRequestRequiredStringHostnameRequest handles test_request_required_string_hostname operation. // -// POST /test_request_required_string_time -func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_hostname +func (s *Server) handleTestRequestRequiredStringHostnameRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time"), + otelogen.OperationID("test_request_required_string_hostname"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostname", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26423,11 +25556,11 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTime", - ID: "test_request_required_string_time", + Name: "TestRequestRequiredStringHostname", + ID: "test_request_required_string_hostname", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringHostnameRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26447,15 +25580,15 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTime", - OperationID: "test_request_required_string_time", + OperationName: "TestRequestRequiredStringHostname", + OperationID: "test_request_required_string_hostname", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = string Params = struct{} Response = Error ) @@ -26468,11 +25601,11 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringTime(ctx, request) + return s.h.TestRequestRequiredStringHostname(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringTime(ctx, request) + response, err = s.h.TestRequestRequiredStringHostname(ctx, request) } if err != nil { recordError("Internal", err) @@ -26480,23 +25613,23 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, w ht return } - if err := encodeTestRequestRequiredStringTimeResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringHostnameResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringTimeArrayRequest handles test_request_required_string_time_array operation. +// HandleTestRequestRequiredStringHostnameArrayRequest handles test_request_required_string_hostname_array operation. // -// POST /test_request_required_string_time_array -func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_hostname_array +func (s *Server) handleTestRequestRequiredStringHostnameArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_array"), + otelogen.OperationID("test_request_required_string_hostname_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26520,11 +25653,11 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeArray", - ID: "test_request_required_string_time_array", + Name: "TestRequestRequiredStringHostnameArray", + ID: "test_request_required_string_hostname_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringHostnameArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26544,15 +25677,15 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeArray", - OperationID: "test_request_required_string_time_array", + OperationName: "TestRequestRequiredStringHostnameArray", + OperationID: "test_request_required_string_hostname_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []string Params = struct{} Response = Error ) @@ -26565,11 +25698,11 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringTimeArray(ctx, request) + return s.h.TestRequestRequiredStringHostnameArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeArray(ctx, request) + response, err = s.h.TestRequestRequiredStringHostnameArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -26577,23 +25710,23 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringHostnameArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringTimeArrayArrayRequest handles test_request_required_string_time_array_array operation. +// HandleTestRequestRequiredStringHostnameArrayArrayRequest handles test_request_required_string_hostname_array_array operation. // -// POST /test_request_required_string_time_array_array -func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_hostname_array_array +func (s *Server) handleTestRequestRequiredStringHostnameArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_array_array"), + otelogen.OperationID("test_request_required_string_hostname_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26617,11 +25750,11 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeArrayArray", - ID: "test_request_required_string_time_array_array", + Name: "TestRequestRequiredStringHostnameArrayArray", + ID: "test_request_required_string_hostname_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringHostnameArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26641,15 +25774,15 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeArrayArray", - OperationID: "test_request_required_string_time_array_array", + OperationName: "TestRequestRequiredStringHostnameArrayArray", + OperationID: "test_request_required_string_hostname_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]string Params = struct{} Response = Error ) @@ -26662,11 +25795,11 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) + return s.h.TestRequestRequiredStringHostnameArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringHostnameArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -26674,23 +25807,23 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringHostnameArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringTimeNullableRequest handles test_request_required_string_time_nullable operation. +// HandleTestRequestRequiredStringHostnameNullableRequest handles test_request_required_string_hostname_nullable operation. // -// POST /test_request_required_string_time_nullable -func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_hostname_nullable +func (s *Server) handleTestRequestRequiredStringHostnameNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable"), + otelogen.OperationID("test_request_required_string_hostname_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26714,11 +25847,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeNullable", - ID: "test_request_required_string_time_nullable", + Name: "TestRequestRequiredStringHostnameNullable", + ID: "test_request_required_string_hostname_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringHostnameNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26738,15 +25871,15 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeNullable", - OperationID: "test_request_required_string_time_nullable", + OperationName: "TestRequestRequiredStringHostnameNullable", + OperationID: "test_request_required_string_hostname_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilTime + Request = NilString Params = struct{} Response = Error ) @@ -26759,11 +25892,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringTimeNullable(ctx, request) + return s.h.TestRequestRequiredStringHostnameNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringHostnameNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -26771,23 +25904,23 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringHostnameNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringTimeNullableArrayRequest handles test_request_required_string_time_nullable_array operation. +// HandleTestRequestRequiredStringHostnameNullableArrayRequest handles test_request_required_string_hostname_nullable_array operation. // -// POST /test_request_required_string_time_nullable_array -func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_hostname_nullable_array +func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable_array"), + otelogen.OperationID("test_request_required_string_hostname_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26811,11 +25944,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeNullableArray", - ID: "test_request_required_string_time_nullable_array", + Name: "TestRequestRequiredStringHostnameNullableArray", + ID: "test_request_required_string_hostname_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringHostnameNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26835,15 +25968,15 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeNullableArray", - OperationID: "test_request_required_string_time_nullable_array", + OperationName: "TestRequestRequiredStringHostnameNullableArray", + OperationID: "test_request_required_string_hostname_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilTime + Request = []NilString Params = struct{} Response = Error ) @@ -26856,11 +25989,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) + return s.h.TestRequestRequiredStringHostnameNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringHostnameNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -26868,23 +26001,23 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringHostnameNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringTimeNullableArrayArrayRequest handles test_request_required_string_time_nullable_array_array operation. +// HandleTestRequestRequiredStringHostnameNullableArrayArrayRequest handles test_request_required_string_hostname_nullable_array_array operation. // -// POST /test_request_required_string_time_nullable_array_array -func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_hostname_nullable_array_array +func (s *Server) handleTestRequestRequiredStringHostnameNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable_array_array"), + otelogen.OperationID("test_request_required_string_hostname_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringHostnameNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -26908,11 +26041,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeNullableArrayArray", - ID: "test_request_required_string_time_nullable_array_array", + Name: "TestRequestRequiredStringHostnameNullableArrayArray", + ID: "test_request_required_string_hostname_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringHostnameNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -26932,15 +26065,15 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeNullableArrayArray", - OperationID: "test_request_required_string_time_nullable_array_array", + OperationName: "TestRequestRequiredStringHostnameNullableArrayArray", + OperationID: "test_request_required_string_hostname_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilTime + Request = [][]NilString Params = struct{} Response = Error ) @@ -26953,11 +26086,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringHostnameNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringHostnameNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -26965,23 +26098,23 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringURIRequest handles test_request_required_string_uri operation. +// HandleTestRequestRequiredStringIPRequest handles test_request_required_string_ip operation. // -// POST /test_request_required_string_uri -func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ip +func (s *Server) handleTestRequestRequiredStringIPRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri"), + otelogen.OperationID("test_request_required_string_ip"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURI", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIP", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27005,11 +26138,11 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, w htt } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURI", - ID: "test_request_required_string_uri", + Name: "TestRequestRequiredStringIP", + ID: "test_request_required_string_ip", } ) - request, close, err := s.decodeTestRequestRequiredStringURIRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIPRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27029,15 +26162,15 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, w htt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURI", - OperationID: "test_request_required_string_uri", + OperationName: "TestRequestRequiredStringIP", + OperationID: "test_request_required_string_ip", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = url.URL + Request = netip.Addr Params = struct{} Response = Error ) @@ -27050,11 +26183,11 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, w htt mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringURI(ctx, request) + return s.h.TestRequestRequiredStringIP(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringURI(ctx, request) + response, err = s.h.TestRequestRequiredStringIP(ctx, request) } if err != nil { recordError("Internal", err) @@ -27062,23 +26195,23 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, w htt return } - if err := encodeTestRequestRequiredStringURIResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIPResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringURIArrayRequest handles test_request_required_string_uri_array operation. +// HandleTestRequestRequiredStringIPArrayRequest handles test_request_required_string_ip_array operation. // -// POST /test_request_required_string_uri_array -func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ip_array +func (s *Server) handleTestRequestRequiredStringIPArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_array"), + otelogen.OperationID("test_request_required_string_ip_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURIArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27102,11 +26235,11 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURIArray", - ID: "test_request_required_string_uri_array", + Name: "TestRequestRequiredStringIPArray", + ID: "test_request_required_string_ip_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURIArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIPArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27126,15 +26259,15 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURIArray", - OperationID: "test_request_required_string_uri_array", + OperationName: "TestRequestRequiredStringIPArray", + OperationID: "test_request_required_string_ip_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []url.URL + Request = []netip.Addr Params = struct{} Response = Error ) @@ -27147,11 +26280,11 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringURIArray(ctx, request) + return s.h.TestRequestRequiredStringIPArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringURIArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIPArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -27159,23 +26292,23 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringURIArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIPArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringURIArrayArrayRequest handles test_request_required_string_uri_array_array operation. +// HandleTestRequestRequiredStringIPArrayArrayRequest handles test_request_required_string_ip_array_array operation. // -// POST /test_request_required_string_uri_array_array -func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ip_array_array +func (s *Server) handleTestRequestRequiredStringIPArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_array_array"), + otelogen.OperationID("test_request_required_string_ip_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURIArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27199,11 +26332,11 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURIArrayArray", - ID: "test_request_required_string_uri_array_array", + Name: "TestRequestRequiredStringIPArrayArray", + ID: "test_request_required_string_ip_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURIArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIPArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27223,15 +26356,15 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURIArrayArray", - OperationID: "test_request_required_string_uri_array_array", + OperationName: "TestRequestRequiredStringIPArrayArray", + OperationID: "test_request_required_string_ip_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]url.URL + Request = [][]netip.Addr Params = struct{} Response = Error ) @@ -27244,11 +26377,11 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringURIArrayArray(ctx, request) + return s.h.TestRequestRequiredStringIPArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringURIArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIPArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -27256,23 +26389,23 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringURIArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIPArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringURINullableRequest handles test_request_required_string_uri_nullable operation. +// HandleTestRequestRequiredStringIPNullableRequest handles test_request_required_string_ip_nullable operation. // -// POST /test_request_required_string_uri_nullable -func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ip_nullable +func (s *Server) handleTestRequestRequiredStringIPNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable"), + otelogen.OperationID("test_request_required_string_ip_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27296,11 +26429,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURINullable", - ID: "test_request_required_string_uri_nullable", + Name: "TestRequestRequiredStringIPNullable", + ID: "test_request_required_string_ip_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringURINullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIPNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27320,15 +26453,15 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURINullable", - OperationID: "test_request_required_string_uri_nullable", + OperationName: "TestRequestRequiredStringIPNullable", + OperationID: "test_request_required_string_ip_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilURI + Request = NilIP Params = struct{} Response = Error ) @@ -27341,11 +26474,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringURINullable(ctx, request) + return s.h.TestRequestRequiredStringIPNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringURINullable(ctx, request) + response, err = s.h.TestRequestRequiredStringIPNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -27353,23 +26486,23 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringURINullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIPNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringURINullableArrayRequest handles test_request_required_string_uri_nullable_array operation. +// HandleTestRequestRequiredStringIPNullableArrayRequest handles test_request_required_string_ip_nullable_array operation. // -// POST /test_request_required_string_uri_nullable_array -func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ip_nullable_array +func (s *Server) handleTestRequestRequiredStringIPNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable_array"), + otelogen.OperationID("test_request_required_string_ip_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27393,11 +26526,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURINullableArray", - ID: "test_request_required_string_uri_nullable_array", + Name: "TestRequestRequiredStringIPNullableArray", + ID: "test_request_required_string_ip_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURINullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIPNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27417,15 +26550,15 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURINullableArray", - OperationID: "test_request_required_string_uri_nullable_array", + OperationName: "TestRequestRequiredStringIPNullableArray", + OperationID: "test_request_required_string_ip_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilURI + Request = []NilIP Params = struct{} Response = Error ) @@ -27438,11 +26571,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringURINullableArray(ctx, request) + return s.h.TestRequestRequiredStringIPNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringURINullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIPNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -27450,23 +26583,23 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringURINullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIPNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringURINullableArrayArrayRequest handles test_request_required_string_uri_nullable_array_array operation. +// HandleTestRequestRequiredStringIPNullableArrayArrayRequest handles test_request_required_string_ip_nullable_array_array operation. // -// POST /test_request_required_string_uri_nullable_array_array -func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ip_nullable_array_array +func (s *Server) handleTestRequestRequiredStringIPNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable_array_array"), + otelogen.OperationID("test_request_required_string_ip_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIPNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27490,11 +26623,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURINullableArrayArray", - ID: "test_request_required_string_uri_nullable_array_array", + Name: "TestRequestRequiredStringIPNullableArrayArray", + ID: "test_request_required_string_ip_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURINullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIPNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27514,15 +26647,15 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURINullableArrayArray", - OperationID: "test_request_required_string_uri_nullable_array_array", + OperationName: "TestRequestRequiredStringIPNullableArrayArray", + OperationID: "test_request_required_string_ip_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilURI + Request = [][]NilIP Params = struct{} Response = Error ) @@ -27535,11 +26668,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringIPNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIPNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -27547,23 +26680,23 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg return } - if err := encodeTestRequestRequiredStringURINullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIPNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUUIDRequest handles test_request_required_string_uuid operation. +// HandleTestRequestRequiredStringInt32Request handles test_request_required_string_int32 operation. // -// POST /test_request_required_string_uuid -func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int32 +func (s *Server) handleTestRequestRequiredStringInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid"), + otelogen.OperationID("test_request_required_string_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUID", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27587,11 +26720,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUID", - ID: "test_request_required_string_uuid", + Name: "TestRequestRequiredStringInt32", + ID: "test_request_required_string_int32", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27611,15 +26744,15 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUID", - OperationID: "test_request_required_string_uuid", + OperationName: "TestRequestRequiredStringInt32", + OperationID: "test_request_required_string_int32", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = uuid.UUID + Request = int32 Params = struct{} Response = Error ) @@ -27632,11 +26765,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUUID(ctx, request) + return s.h.TestRequestRequiredStringInt32(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUUID(ctx, request) + response, err = s.h.TestRequestRequiredStringInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -27644,23 +26777,23 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, w ht return } - if err := encodeTestRequestRequiredStringUUIDResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUUIDArrayRequest handles test_request_required_string_uuid_array operation. +// HandleTestRequestRequiredStringInt32ArrayRequest handles test_request_required_string_int32_array operation. // -// POST /test_request_required_string_uuid_array -func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int32_array +func (s *Server) handleTestRequestRequiredStringInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_array"), + otelogen.OperationID("test_request_required_string_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27684,11 +26817,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDArray", - ID: "test_request_required_string_uuid_array", + Name: "TestRequestRequiredStringInt32Array", + ID: "test_request_required_string_int32_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27708,15 +26841,15 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDArray", - OperationID: "test_request_required_string_uuid_array", + OperationName: "TestRequestRequiredStringInt32Array", + OperationID: "test_request_required_string_int32_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []uuid.UUID + Request = []int32 Params = struct{} Response = Error ) @@ -27729,11 +26862,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUUIDArray(ctx, request) + return s.h.TestRequestRequiredStringInt32Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -27741,23 +26874,23 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUUIDArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUUIDArrayArrayRequest handles test_request_required_string_uuid_array_array operation. +// HandleTestRequestRequiredStringInt32ArrayArrayRequest handles test_request_required_string_int32_array_array operation. // -// POST /test_request_required_string_uuid_array_array -func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int32_array_array +func (s *Server) handleTestRequestRequiredStringInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_array_array"), + otelogen.OperationID("test_request_required_string_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27781,11 +26914,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDArrayArray", - ID: "test_request_required_string_uuid_array_array", + Name: "TestRequestRequiredStringInt32ArrayArray", + ID: "test_request_required_string_int32_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27805,15 +26938,15 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDArrayArray", - OperationID: "test_request_required_string_uuid_array_array", + OperationName: "TestRequestRequiredStringInt32ArrayArray", + OperationID: "test_request_required_string_int32_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]uuid.UUID + Request = [][]int32 Params = struct{} Response = Error ) @@ -27826,11 +26959,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) + return s.h.TestRequestRequiredStringInt32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -27838,23 +26971,23 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUUIDArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUUIDNullableRequest handles test_request_required_string_uuid_nullable operation. +// HandleTestRequestRequiredStringInt32NullableRequest handles test_request_required_string_int32_nullable operation. // -// POST /test_request_required_string_uuid_nullable -func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int32_nullable +func (s *Server) handleTestRequestRequiredStringInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable"), + otelogen.OperationID("test_request_required_string_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27878,11 +27011,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDNullable", - ID: "test_request_required_string_uuid_nullable", + Name: "TestRequestRequiredStringInt32Nullable", + ID: "test_request_required_string_int32_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27902,15 +27035,15 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDNullable", - OperationID: "test_request_required_string_uuid_nullable", + OperationName: "TestRequestRequiredStringInt32Nullable", + OperationID: "test_request_required_string_int32_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilUUID + Request = NilStringInt32 Params = struct{} Response = Error ) @@ -27923,11 +27056,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUUIDNullable(ctx, request) + return s.h.TestRequestRequiredStringInt32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -27935,23 +27068,23 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringUUIDNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUUIDNullableArrayRequest handles test_request_required_string_uuid_nullable_array operation. +// HandleTestRequestRequiredStringInt32NullableArrayRequest handles test_request_required_string_int32_nullable_array operation. // -// POST /test_request_required_string_uuid_nullable_array -func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int32_nullable_array +func (s *Server) handleTestRequestRequiredStringInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable_array"), + otelogen.OperationID("test_request_required_string_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -27975,11 +27108,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDNullableArray", - ID: "test_request_required_string_uuid_nullable_array", + Name: "TestRequestRequiredStringInt32NullableArray", + ID: "test_request_required_string_int32_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -27999,15 +27132,15 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDNullableArray", - OperationID: "test_request_required_string_uuid_nullable_array", + OperationName: "TestRequestRequiredStringInt32NullableArray", + OperationID: "test_request_required_string_int32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUUID + Request = []NilStringInt32 Params = struct{} Response = Error ) @@ -28020,11 +27153,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) + return s.h.TestRequestRequiredStringInt32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -28032,23 +27165,23 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringUUIDNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUUIDNullableArrayArrayRequest handles test_request_required_string_uuid_nullable_array_array operation. +// HandleTestRequestRequiredStringInt32NullableArrayArrayRequest handles test_request_required_string_int32_nullable_array_array operation. // -// POST /test_request_required_string_uuid_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int32_nullable_array_array +func (s *Server) handleTestRequestRequiredStringInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable_array_array"), + otelogen.OperationID("test_request_required_string_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28072,11 +27205,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDNullableArrayArray", - ID: "test_request_required_string_uuid_nullable_array_array", + Name: "TestRequestRequiredStringInt32NullableArrayArray", + ID: "test_request_required_string_int32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28096,15 +27229,15 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDNullableArrayArray", - OperationID: "test_request_required_string_uuid_nullable_array_array", + OperationName: "TestRequestRequiredStringInt32NullableArrayArray", + OperationID: "test_request_required_string_int32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUUID + Request = [][]NilStringInt32 Params = struct{} Response = Error ) @@ -28117,11 +27250,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringInt32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -28129,23 +27262,23 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixRequest handles test_request_required_string_unix operation. +// HandleTestRequestRequiredStringInt64Request handles test_request_required_string_int64 operation. // -// POST /test_request_required_string_unix -func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int64 +func (s *Server) handleTestRequestRequiredStringInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix"), + otelogen.OperationID("test_request_required_string_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnix", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28169,11 +27302,11 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnix", - ID: "test_request_required_string_unix", + Name: "TestRequestRequiredStringInt64", + ID: "test_request_required_string_int64", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28193,15 +27326,15 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnix", - OperationID: "test_request_required_string_unix", + OperationName: "TestRequestRequiredStringInt64", + OperationID: "test_request_required_string_int64", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = int64 Params = struct{} Response = Error ) @@ -28214,11 +27347,11 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnix(ctx, request) + return s.h.TestRequestRequiredStringInt64(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnix(ctx, request) + response, err = s.h.TestRequestRequiredStringInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -28226,23 +27359,23 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, w ht return } - if err := encodeTestRequestRequiredStringUnixResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixArrayRequest handles test_request_required_string_unix_array operation. +// HandleTestRequestRequiredStringInt64ArrayRequest handles test_request_required_string_int64_array operation. // -// POST /test_request_required_string_unix_array -func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int64_array +func (s *Server) handleTestRequestRequiredStringInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_array"), + otelogen.OperationID("test_request_required_string_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28266,11 +27399,11 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixArray", - ID: "test_request_required_string_unix_array", + Name: "TestRequestRequiredStringInt64Array", + ID: "test_request_required_string_int64_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28290,15 +27423,15 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixArray", - OperationID: "test_request_required_string_unix_array", + OperationName: "TestRequestRequiredStringInt64Array", + OperationID: "test_request_required_string_int64_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []int64 Params = struct{} Response = Error ) @@ -28311,11 +27444,11 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixArray(ctx, request) + return s.h.TestRequestRequiredStringInt64Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -28323,23 +27456,23 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixArrayArrayRequest handles test_request_required_string_unix_array_array operation. +// HandleTestRequestRequiredStringInt64ArrayArrayRequest handles test_request_required_string_int64_array_array operation. // -// POST /test_request_required_string_unix_array_array -func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int64_array_array +func (s *Server) handleTestRequestRequiredStringInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_array_array"), + otelogen.OperationID("test_request_required_string_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28363,11 +27496,11 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixArrayArray", - ID: "test_request_required_string_unix_array_array", + Name: "TestRequestRequiredStringInt64ArrayArray", + ID: "test_request_required_string_int64_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28387,15 +27520,15 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixArrayArray", - OperationID: "test_request_required_string_unix_array_array", + OperationName: "TestRequestRequiredStringInt64ArrayArray", + OperationID: "test_request_required_string_int64_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]int64 Params = struct{} Response = Error ) @@ -28408,11 +27541,11 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) + return s.h.TestRequestRequiredStringInt64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -28420,23 +27553,23 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUnixArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMicroRequest handles test_request_required_string_unix-micro operation. +// HandleTestRequestRequiredStringInt64NullableRequest handles test_request_required_string_int64_nullable operation. // -// POST /test_request_required_string_unix-micro -func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int64_nullable +func (s *Server) handleTestRequestRequiredStringInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro"), + otelogen.OperationID("test_request_required_string_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicro", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28460,11 +27593,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicro", - ID: "test_request_required_string_unix-micro", + Name: "TestRequestRequiredStringInt64Nullable", + ID: "test_request_required_string_int64_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28484,15 +27617,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicro", - OperationID: "test_request_required_string_unix-micro", + OperationName: "TestRequestRequiredStringInt64Nullable", + OperationID: "test_request_required_string_int64_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = NilStringInt64 Params = struct{} Response = Error ) @@ -28505,11 +27638,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMicro(ctx, request) + return s.h.TestRequestRequiredStringInt64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicro(ctx, request) + response, err = s.h.TestRequestRequiredStringInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -28517,23 +27650,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixMicroResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMicroArrayRequest handles test_request_required_string_unix-micro_array operation. +// HandleTestRequestRequiredStringInt64NullableArrayRequest handles test_request_required_string_int64_nullable_array operation. // -// POST /test_request_required_string_unix-micro_array -func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int64_nullable_array +func (s *Server) handleTestRequestRequiredStringInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_array"), + otelogen.OperationID("test_request_required_string_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28557,11 +27690,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroArray", - ID: "test_request_required_string_unix-micro_array", + Name: "TestRequestRequiredStringInt64NullableArray", + ID: "test_request_required_string_int64_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28581,15 +27714,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroArray", - OperationID: "test_request_required_string_unix-micro_array", + OperationName: "TestRequestRequiredStringInt64NullableArray", + OperationID: "test_request_required_string_int64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilStringInt64 Params = struct{} Response = Error ) @@ -28602,11 +27735,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) + return s.h.TestRequestRequiredStringInt64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -28614,23 +27747,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUnixMicroArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMicroArrayArrayRequest handles test_request_required_string_unix-micro_array_array operation. +// HandleTestRequestRequiredStringInt64NullableArrayArrayRequest handles test_request_required_string_int64_nullable_array_array operation. // -// POST /test_request_required_string_unix-micro_array_array -func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_int64_nullable_array_array +func (s *Server) handleTestRequestRequiredStringInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_array_array"), + otelogen.OperationID("test_request_required_string_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28654,11 +27787,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroArrayArray", - ID: "test_request_required_string_unix-micro_array_array", + Name: "TestRequestRequiredStringInt64NullableArrayArray", + ID: "test_request_required_string_int64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28678,15 +27811,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroArrayArray", - OperationID: "test_request_required_string_unix-micro_array_array", + OperationName: "TestRequestRequiredStringInt64NullableArrayArray", + OperationID: "test_request_required_string_int64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilStringInt64 Params = struct{} Response = Error ) @@ -28699,11 +27832,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) + return s.h.TestRequestRequiredStringInt64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -28711,23 +27844,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args return } - if err := encodeTestRequestRequiredStringUnixMicroArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMicroNullableRequest handles test_request_required_string_unix-micro_nullable operation. +// HandleTestRequestRequiredStringIpv4Request handles test_request_required_string_ipv4 operation. // -// POST /test_request_required_string_unix-micro_nullable -func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv4 +func (s *Server) handleTestRequestRequiredStringIpv4Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_nullable"), + otelogen.OperationID("test_request_required_string_ipv4"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28751,11 +27884,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroNullable", - ID: "test_request_required_string_unix-micro_nullable", + Name: "TestRequestRequiredStringIpv4", + ID: "test_request_required_string_ipv4", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv4Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28775,15 +27908,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroNullable", - OperationID: "test_request_required_string_unix-micro_nullable", + OperationName: "TestRequestRequiredStringIpv4", + OperationID: "test_request_required_string_ipv4", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilStringUnixMicro + Request = netip.Addr Params = struct{} Response = Error ) @@ -28796,11 +27929,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) + return s.h.TestRequestRequiredStringIpv4(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv4(ctx, request) } if err != nil { recordError("Internal", err) @@ -28808,23 +27941,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 return } - if err := encodeTestRequestRequiredStringUnixMicroNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv4Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMicroNullableArrayRequest handles test_request_required_string_unix-micro_nullable_array operation. +// HandleTestRequestRequiredStringIpv4ArrayRequest handles test_request_required_string_ipv4_array operation. // -// POST /test_request_required_string_unix-micro_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv4_array +func (s *Server) handleTestRequestRequiredStringIpv4ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_nullable_array"), + otelogen.OperationID("test_request_required_string_ipv4_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28848,11 +27981,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroNullableArray", - ID: "test_request_required_string_unix-micro_nullable_array", + Name: "TestRequestRequiredStringIpv4Array", + ID: "test_request_required_string_ipv4_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv4ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28872,15 +28005,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroNullableArray", - OperationID: "test_request_required_string_unix-micro_nullable_array", + OperationName: "TestRequestRequiredStringIpv4Array", + OperationID: "test_request_required_string_ipv4_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixMicro + Request = []netip.Addr Params = struct{} Response = Error ) @@ -28893,11 +28026,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) + return s.h.TestRequestRequiredStringIpv4Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv4Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -28905,23 +28038,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUnixMicroNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv4ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest handles test_request_required_string_unix-micro_nullable_array_array operation. +// HandleTestRequestRequiredStringIpv4ArrayArrayRequest handles test_request_required_string_ipv4_array_array operation. // -// POST /test_request_required_string_unix-micro_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv4_array_array +func (s *Server) handleTestRequestRequiredStringIpv4ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_required_string_ipv4_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -28945,11 +28078,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroNullableArrayArray", - ID: "test_request_required_string_unix-micro_nullable_array_array", + Name: "TestRequestRequiredStringIpv4ArrayArray", + ID: "test_request_required_string_ipv4_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -28969,15 +28102,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroNullableArrayArray", - OperationID: "test_request_required_string_unix-micro_nullable_array_array", + OperationName: "TestRequestRequiredStringIpv4ArrayArray", + OperationID: "test_request_required_string_ipv4_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixMicro + Request = [][]netip.Addr Params = struct{} Response = Error ) @@ -28990,11 +28123,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringIpv4ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv4ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -29002,23 +28135,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque return } - if err := encodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv4ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMilliRequest handles test_request_required_string_unix-milli operation. +// HandleTestRequestRequiredStringIpv4NullableRequest handles test_request_required_string_ipv4_nullable operation. // -// POST /test_request_required_string_unix-milli -func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv4_nullable +func (s *Server) handleTestRequestRequiredStringIpv4NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli"), + otelogen.OperationID("test_request_required_string_ipv4_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilli", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29042,11 +28175,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilli", - ID: "test_request_required_string_unix-milli", + Name: "TestRequestRequiredStringIpv4Nullable", + ID: "test_request_required_string_ipv4_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv4NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29066,15 +28199,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilli", - OperationID: "test_request_required_string_unix-milli", + OperationName: "TestRequestRequiredStringIpv4Nullable", + OperationID: "test_request_required_string_ipv4_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = NilIPv4 Params = struct{} Response = Error ) @@ -29087,11 +28220,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMilli(ctx, request) + return s.h.TestRequestRequiredStringIpv4Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilli(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv4Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -29099,23 +28232,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixMilliResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv4NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMilliArrayRequest handles test_request_required_string_unix-milli_array operation. +// HandleTestRequestRequiredStringIpv4NullableArrayRequest handles test_request_required_string_ipv4_nullable_array operation. // -// POST /test_request_required_string_unix-milli_array -func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv4_nullable_array +func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_array"), + otelogen.OperationID("test_request_required_string_ipv4_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29139,11 +28272,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliArray", - ID: "test_request_required_string_unix-milli_array", + Name: "TestRequestRequiredStringIpv4NullableArray", + ID: "test_request_required_string_ipv4_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv4NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29163,15 +28296,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliArray", - OperationID: "test_request_required_string_unix-milli_array", + OperationName: "TestRequestRequiredStringIpv4NullableArray", + OperationID: "test_request_required_string_ipv4_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilIPv4 Params = struct{} Response = Error ) @@ -29184,11 +28317,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) + return s.h.TestRequestRequiredStringIpv4NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv4NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -29196,23 +28329,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUnixMilliArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv4NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMilliArrayArrayRequest handles test_request_required_string_unix-milli_array_array operation. +// HandleTestRequestRequiredStringIpv4NullableArrayArrayRequest handles test_request_required_string_ipv4_nullable_array_array operation. // -// POST /test_request_required_string_unix-milli_array_array -func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv4_nullable_array_array +func (s *Server) handleTestRequestRequiredStringIpv4NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_array_array"), + otelogen.OperationID("test_request_required_string_ipv4_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv4NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29236,11 +28369,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliArrayArray", - ID: "test_request_required_string_unix-milli_array_array", + Name: "TestRequestRequiredStringIpv4NullableArrayArray", + ID: "test_request_required_string_ipv4_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29260,15 +28393,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliArrayArray", - OperationID: "test_request_required_string_unix-milli_array_array", + OperationName: "TestRequestRequiredStringIpv4NullableArrayArray", + OperationID: "test_request_required_string_ipv4_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilIPv4 Params = struct{} Response = Error ) @@ -29281,11 +28414,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) + return s.h.TestRequestRequiredStringIpv4NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv4NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -29293,23 +28426,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args return } - if err := encodeTestRequestRequiredStringUnixMilliArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMilliNullableRequest handles test_request_required_string_unix-milli_nullable operation. +// HandleTestRequestRequiredStringIpv6Request handles test_request_required_string_ipv6 operation. // -// POST /test_request_required_string_unix-milli_nullable -func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv6 +func (s *Server) handleTestRequestRequiredStringIpv6Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_nullable"), + otelogen.OperationID("test_request_required_string_ipv6"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29333,11 +28466,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliNullable", - ID: "test_request_required_string_unix-milli_nullable", + Name: "TestRequestRequiredStringIpv6", + ID: "test_request_required_string_ipv6", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv6Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29357,15 +28490,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliNullable", - OperationID: "test_request_required_string_unix-milli_nullable", + OperationName: "TestRequestRequiredStringIpv6", + OperationID: "test_request_required_string_ipv6", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilStringUnixMilli + Request = netip.Addr Params = struct{} Response = Error ) @@ -29378,11 +28511,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) + return s.h.TestRequestRequiredStringIpv6(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv6(ctx, request) } if err != nil { recordError("Internal", err) @@ -29390,23 +28523,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 return } - if err := encodeTestRequestRequiredStringUnixMilliNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv6Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMilliNullableArrayRequest handles test_request_required_string_unix-milli_nullable_array operation. +// HandleTestRequestRequiredStringIpv6ArrayRequest handles test_request_required_string_ipv6_array operation. // -// POST /test_request_required_string_unix-milli_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv6_array +func (s *Server) handleTestRequestRequiredStringIpv6ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_nullable_array"), + otelogen.OperationID("test_request_required_string_ipv6_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29430,11 +28563,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliNullableArray", - ID: "test_request_required_string_unix-milli_nullable_array", + Name: "TestRequestRequiredStringIpv6Array", + ID: "test_request_required_string_ipv6_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv6ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29454,15 +28587,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliNullableArray", - OperationID: "test_request_required_string_unix-milli_nullable_array", + OperationName: "TestRequestRequiredStringIpv6Array", + OperationID: "test_request_required_string_ipv6_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixMilli + Request = []netip.Addr Params = struct{} Response = Error ) @@ -29475,11 +28608,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) + return s.h.TestRequestRequiredStringIpv6Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv6Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -29487,23 +28620,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUnixMilliNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv6ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest handles test_request_required_string_unix-milli_nullable_array_array operation. +// HandleTestRequestRequiredStringIpv6ArrayArrayRequest handles test_request_required_string_ipv6_array_array operation. // -// POST /test_request_required_string_unix-milli_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv6_array_array +func (s *Server) handleTestRequestRequiredStringIpv6ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_required_string_ipv6_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29527,11 +28660,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliNullableArrayArray", - ID: "test_request_required_string_unix-milli_nullable_array_array", + Name: "TestRequestRequiredStringIpv6ArrayArray", + ID: "test_request_required_string_ipv6_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv6ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29551,15 +28684,15 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliNullableArrayArray", - OperationID: "test_request_required_string_unix-milli_nullable_array_array", + OperationName: "TestRequestRequiredStringIpv6ArrayArray", + OperationID: "test_request_required_string_ipv6_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixMilli + Request = [][]netip.Addr Params = struct{} Response = Error ) @@ -29572,11 +28705,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringIpv6ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv6ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -29584,23 +28717,23 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque return } - if err := encodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv6ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNanoRequest handles test_request_required_string_unix-nano operation. +// HandleTestRequestRequiredStringIpv6NullableRequest handles test_request_required_string_ipv6_nullable operation. // -// POST /test_request_required_string_unix-nano -func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv6_nullable +func (s *Server) handleTestRequestRequiredStringIpv6NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano"), + otelogen.OperationID("test_request_required_string_ipv6_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNano", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29624,11 +28757,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNano", - ID: "test_request_required_string_unix-nano", + Name: "TestRequestRequiredStringIpv6Nullable", + ID: "test_request_required_string_ipv6_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv6NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29648,15 +28781,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNano", - OperationID: "test_request_required_string_unix-nano", + OperationName: "TestRequestRequiredStringIpv6Nullable", + OperationID: "test_request_required_string_ipv6_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = NilIPv6 Params = struct{} Response = Error ) @@ -29669,11 +28802,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNano(ctx, request) + return s.h.TestRequestRequiredStringIpv6Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNano(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv6Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -29681,23 +28814,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixNanoResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv6NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNanoArrayRequest handles test_request_required_string_unix-nano_array operation. +// HandleTestRequestRequiredStringIpv6NullableArrayRequest handles test_request_required_string_ipv6_nullable_array operation. // -// POST /test_request_required_string_unix-nano_array -func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv6_nullable_array +func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_array"), + otelogen.OperationID("test_request_required_string_ipv6_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29721,11 +28854,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoArray", - ID: "test_request_required_string_unix-nano_array", + Name: "TestRequestRequiredStringIpv6NullableArray", + ID: "test_request_required_string_ipv6_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv6NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29745,15 +28878,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoArray", - OperationID: "test_request_required_string_unix-nano_array", + OperationName: "TestRequestRequiredStringIpv6NullableArray", + OperationID: "test_request_required_string_ipv6_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilIPv6 Params = struct{} Response = Error ) @@ -29766,11 +28899,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) + return s.h.TestRequestRequiredStringIpv6NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv6NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -29778,23 +28911,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringUnixNanoArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv6NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNanoArrayArrayRequest handles test_request_required_string_unix-nano_array_array operation. +// HandleTestRequestRequiredStringIpv6NullableArrayArrayRequest handles test_request_required_string_ipv6_nullable_array_array operation. // -// POST /test_request_required_string_unix-nano_array_array -func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_ipv6_nullable_array_array +func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_array_array"), + otelogen.OperationID("test_request_required_string_ipv6_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringIpv6NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29818,11 +28951,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoArrayArray", - ID: "test_request_required_string_unix-nano_array_array", + Name: "TestRequestRequiredStringIpv6NullableArrayArray", + ID: "test_request_required_string_ipv6_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29842,15 +28975,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoArrayArray", - OperationID: "test_request_required_string_unix-nano_array_array", + OperationName: "TestRequestRequiredStringIpv6NullableArrayArray", + OperationID: "test_request_required_string_ipv6_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilIPv6 Params = struct{} Response = Error ) @@ -29863,11 +28996,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) + return s.h.TestRequestRequiredStringIpv6NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringIpv6NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -29875,23 +29008,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringUnixNanoArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNanoNullableRequest handles test_request_required_string_unix-nano_nullable operation. +// HandleTestRequestRequiredStringNullableRequest handles test_request_required_string_nullable operation. // -// POST /test_request_required_string_unix-nano_nullable -func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_nullable +func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_nullable"), + otelogen.OperationID("test_request_required_string_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -29915,11 +29048,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoNullable", - ID: "test_request_required_string_unix-nano_nullable", + Name: "TestRequestRequiredStringNullable", + ID: "test_request_required_string_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -29939,15 +29072,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoNullable", - OperationID: "test_request_required_string_unix-nano_nullable", + OperationName: "TestRequestRequiredStringNullable", + OperationID: "test_request_required_string_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilStringUnixNano + Request = NilString Params = struct{} Response = Error ) @@ -29960,11 +29093,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) + return s.h.TestRequestRequiredStringNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -29972,23 +29105,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] return } - if err := encodeTestRequestRequiredStringUnixNanoNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNanoNullableArrayRequest handles test_request_required_string_unix-nano_nullable_array operation. +// HandleTestRequestRequiredStringNullableArrayRequest handles test_request_required_string_nullable_array operation. // -// POST /test_request_required_string_unix-nano_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_nullable_array +func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_nullable_array"), + otelogen.OperationID("test_request_required_string_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30012,11 +29145,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoNullableArray", - ID: "test_request_required_string_unix-nano_nullable_array", + Name: "TestRequestRequiredStringNullableArray", + ID: "test_request_required_string_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30036,15 +29169,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoNullableArray", - OperationID: "test_request_required_string_unix-nano_nullable_array", + OperationName: "TestRequestRequiredStringNullableArray", + OperationID: "test_request_required_string_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixNano + Request = []NilString Params = struct{} Response = Error ) @@ -30057,11 +29190,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) + return s.h.TestRequestRequiredStringNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -30069,23 +29202,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg return } - if err := encodeTestRequestRequiredStringUnixNanoNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest handles test_request_required_string_unix-nano_nullable_array_array operation. +// HandleTestRequestRequiredStringNullableArrayArrayRequest handles test_request_required_string_nullable_array_array operation. // -// POST /test_request_required_string_unix-nano_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_nullable_array_array +func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_required_string_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30109,11 +29242,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoNullableArrayArray", - ID: "test_request_required_string_unix-nano_nullable_array_array", + Name: "TestRequestRequiredStringNullableArrayArray", + ID: "test_request_required_string_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30133,15 +29266,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoNullableArrayArray", - OperationID: "test_request_required_string_unix-nano_nullable_array_array", + OperationName: "TestRequestRequiredStringNullableArrayArray", + OperationID: "test_request_required_string_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixNano + Request = [][]NilString Params = struct{} Response = Error ) @@ -30154,11 +29287,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -30166,23 +29299,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques return } - if err := encodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNullableRequest handles test_request_required_string_unix_nullable operation. +// HandleTestRequestRequiredStringPasswordRequest handles test_request_required_string_password operation. // -// POST /test_request_required_string_unix_nullable -func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password +func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable"), + otelogen.OperationID("test_request_required_string_password"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPassword", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30206,11 +29339,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNullable", - ID: "test_request_required_string_unix_nullable", + Name: "TestRequestRequiredStringPassword", + ID: "test_request_required_string_password", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringPasswordRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30230,15 +29363,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNullable", - OperationID: "test_request_required_string_unix_nullable", + OperationName: "TestRequestRequiredStringPassword", + OperationID: "test_request_required_string_password", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilStringUnixSeconds + Request = string Params = struct{} Response = Error ) @@ -30251,11 +29384,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNullable(ctx, request) + return s.h.TestRequestRequiredStringPassword(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringPassword(ctx, request) } if err != nil { recordError("Internal", err) @@ -30263,23 +29396,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringUnixNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNullableArrayRequest handles test_request_required_string_unix_nullable_array operation. +// HandleTestRequestRequiredStringPasswordArrayRequest handles test_request_required_string_password_array operation. // -// POST /test_request_required_string_unix_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_array +func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable_array"), + otelogen.OperationID("test_request_required_string_password_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30303,11 +29436,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNullableArray", - ID: "test_request_required_string_unix_nullable_array", + Name: "TestRequestRequiredStringPasswordArray", + ID: "test_request_required_string_password_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringPasswordArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30327,15 +29460,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNullableArray", - OperationID: "test_request_required_string_unix_nullable_array", + OperationName: "TestRequestRequiredStringPasswordArray", + OperationID: "test_request_required_string_password_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixSeconds + Request = []string Params = struct{} Response = Error ) @@ -30348,11 +29481,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) + return s.h.TestRequestRequiredStringPasswordArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -30360,23 +29493,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringUnixNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixNullableArrayArrayRequest handles test_request_required_string_unix_nullable_array_array operation. +// HandleTestRequestRequiredStringPasswordArrayArrayRequest handles test_request_required_string_password_array_array operation. // -// POST /test_request_required_string_unix_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_array_array +func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable_array_array"), + otelogen.OperationID("test_request_required_string_password_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30400,11 +29533,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNullableArrayArray", - ID: "test_request_required_string_unix_nullable_array_array", + Name: "TestRequestRequiredStringPasswordArrayArray", + ID: "test_request_required_string_password_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringPasswordArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30424,15 +29557,15 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNullableArrayArray", - OperationID: "test_request_required_string_unix_nullable_array_array", + OperationName: "TestRequestRequiredStringPasswordArrayArray", + OperationID: "test_request_required_string_password_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixSeconds + Request = [][]string Params = struct{} Response = Error ) @@ -30445,11 +29578,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -30457,23 +29590,23 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUnixNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixSecondsRequest handles test_request_required_string_unix-seconds operation. +// HandleTestRequestRequiredStringPasswordNullableRequest handles test_request_required_string_password_nullable operation. // -// POST /test_request_required_string_unix-seconds -func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_nullable +func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds"), + otelogen.OperationID("test_request_required_string_password_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSeconds", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30497,11 +29630,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSeconds", - ID: "test_request_required_string_unix-seconds", + Name: "TestRequestRequiredStringPasswordNullable", + ID: "test_request_required_string_password_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringPasswordNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30521,15 +29654,15 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSeconds", - OperationID: "test_request_required_string_unix-seconds", + OperationName: "TestRequestRequiredStringPasswordNullable", + OperationID: "test_request_required_string_password_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = time.Time + Request = NilString Params = struct{} Response = Error ) @@ -30542,11 +29675,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixSeconds(ctx, request) + return s.h.TestRequestRequiredStringPasswordNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSeconds(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -30554,23 +29687,23 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringUnixSecondsResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixSecondsArrayRequest handles test_request_required_string_unix-seconds_array operation. +// HandleTestRequestRequiredStringPasswordNullableArrayRequest handles test_request_required_string_password_nullable_array operation. // -// POST /test_request_required_string_unix-seconds_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_nullable_array +func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_array"), + otelogen.OperationID("test_request_required_string_password_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30594,11 +29727,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsArray", - ID: "test_request_required_string_unix-seconds_array", + Name: "TestRequestRequiredStringPasswordNullableArray", + ID: "test_request_required_string_password_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30618,15 +29751,15 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsArray", - OperationID: "test_request_required_string_unix-seconds_array", + OperationName: "TestRequestRequiredStringPasswordNullableArray", + OperationID: "test_request_required_string_password_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilString Params = struct{} Response = Error ) @@ -30639,11 +29772,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) + return s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -30651,23 +29784,23 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringUnixSecondsArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixSecondsArrayArrayRequest handles test_request_required_string_unix-seconds_array_array operation. +// HandleTestRequestRequiredStringPasswordNullableArrayArrayRequest handles test_request_required_string_password_nullable_array_array operation. // -// POST /test_request_required_string_unix-seconds_array_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_nullable_array_array +func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_array_array"), + otelogen.OperationID("test_request_required_string_password_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30691,11 +29824,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsArrayArray", - ID: "test_request_required_string_unix-seconds_array_array", + Name: "TestRequestRequiredStringPasswordNullableArrayArray", + ID: "test_request_required_string_password_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30715,15 +29848,15 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsArrayArray", - OperationID: "test_request_required_string_unix-seconds_array_array", + OperationName: "TestRequestRequiredStringPasswordNullableArrayArray", + OperationID: "test_request_required_string_password_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilString Params = struct{} Response = Error ) @@ -30736,11 +29869,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) + return s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -30748,23 +29881,23 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg return } - if err := encodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixSecondsNullableRequest handles test_request_required_string_unix-seconds_nullable operation. +// HandleTestRequestRequiredStringTimeRequest handles test_request_required_string_time operation. // -// POST /test_request_required_string_unix-seconds_nullable -func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time +func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_nullable"), + otelogen.OperationID("test_request_required_string_time"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTime", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30788,11 +29921,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsNullable", - ID: "test_request_required_string_unix-seconds_nullable", + Name: "TestRequestRequiredStringTime", + ID: "test_request_required_string_time", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringTimeRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30812,15 +29945,15 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsNullable", - OperationID: "test_request_required_string_unix-seconds_nullable", + OperationName: "TestRequestRequiredStringTime", + OperationID: "test_request_required_string_time", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = NilStringUnixSeconds + Request = time.Time Params = struct{} Response = Error ) @@ -30833,11 +29966,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) + return s.h.TestRequestRequiredStringTime(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringTime(ctx, request) } if err != nil { recordError("Internal", err) @@ -30845,23 +29978,23 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args return } - if err := encodeTestRequestRequiredStringUnixSecondsNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixSecondsNullableArrayRequest handles test_request_required_string_unix-seconds_nullable_array operation. +// HandleTestRequestRequiredStringTimeArrayRequest handles test_request_required_string_time_array operation. // -// POST /test_request_required_string_unix-seconds_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_array +func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_required_string_time_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30885,11 +30018,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsNullableArray", - ID: "test_request_required_string_unix-seconds_nullable_array", + Name: "TestRequestRequiredStringTimeArray", + ID: "test_request_required_string_time_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringTimeArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -30909,15 +30042,15 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsNullableArray", - OperationID: "test_request_required_string_unix-seconds_nullable_array", + OperationName: "TestRequestRequiredStringTimeArray", + OperationID: "test_request_required_string_time_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixSeconds + Request = []time.Time Params = struct{} Response = Error ) @@ -30930,11 +30063,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) + return s.h.TestRequestRequiredStringTimeArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -30942,23 +30075,23 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( return } - if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest handles test_request_required_string_unix-seconds_nullable_array_array operation. +// HandleTestRequestRequiredStringTimeArrayArrayRequest handles test_request_required_string_time_array_array operation. // -// POST /test_request_required_string_unix-seconds_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_array_array +func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_required_string_time_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -30982,11 +30115,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsNullableArrayArray", - ID: "test_request_required_string_unix-seconds_nullable_array_array", + Name: "TestRequestRequiredStringTimeArrayArray", + ID: "test_request_required_string_time_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringTimeArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31006,15 +30139,15 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsNullableArrayArray", - OperationID: "test_request_required_string_unix-seconds_nullable_array_array", + OperationName: "TestRequestRequiredStringTimeArrayArray", + OperationID: "test_request_required_string_time_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixSeconds + Request = [][]time.Time Params = struct{} Response = Error ) @@ -31027,11 +30160,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -31039,23 +30172,23 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq return } - if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringRequest handles test_request_string operation. +// HandleTestRequestRequiredStringTimeNullableRequest handles test_request_required_string_time_nullable operation. // -// POST /test_request_string -func (s *Server) handleTestRequestStringRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_nullable +func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string"), + otelogen.OperationID("test_request_required_string_time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestString", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31079,11 +30212,11 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, w http.ResponseW } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestString", - ID: "test_request_string", + Name: "TestRequestRequiredStringTimeNullable", + ID: "test_request_required_string_time_nullable", } ) - request, close, err := s.decodeTestRequestStringRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringTimeNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31103,15 +30236,15 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, w http.ResponseW if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestString", - OperationID: "test_request_string", + OperationName: "TestRequestRequiredStringTimeNullable", + OperationID: "test_request_required_string_time_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptString + Request = NilTime Params = struct{} Response = Error ) @@ -31124,11 +30257,11 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, w http.ResponseW mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestString(ctx, request) + return s.h.TestRequestRequiredStringTimeNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestString(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -31136,23 +30269,23 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, w http.ResponseW return } - if err := encodeTestRequestStringResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringArrayRequest handles test_request_string_array operation. +// HandleTestRequestRequiredStringTimeNullableArrayRequest handles test_request_required_string_time_nullable_array operation. // -// POST /test_request_string_array -func (s *Server) handleTestRequestStringArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_nullable_array +func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_array"), + otelogen.OperationID("test_request_required_string_time_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31176,11 +30309,11 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringArray", - ID: "test_request_string_array", + Name: "TestRequestRequiredStringTimeNullableArray", + ID: "test_request_required_string_time_nullable_array", } ) - request, close, err := s.decodeTestRequestStringArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31200,15 +30333,15 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringArray", - OperationID: "test_request_string_array", + OperationName: "TestRequestRequiredStringTimeNullableArray", + OperationID: "test_request_required_string_time_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []NilTime Params = struct{} Response = Error ) @@ -31221,11 +30354,11 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringArray(ctx, request) + return s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -31233,23 +30366,23 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, w http.Resp return } - if err := encodeTestRequestStringArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringArrayArrayRequest handles test_request_string_array_array operation. +// HandleTestRequestRequiredStringTimeNullableArrayArrayRequest handles test_request_required_string_time_nullable_array_array operation. // -// POST /test_request_string_array_array -func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_nullable_array_array +func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_array_array"), + otelogen.OperationID("test_request_required_string_time_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31273,11 +30406,11 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringArrayArray", - ID: "test_request_string_array_array", + Name: "TestRequestRequiredStringTimeNullableArrayArray", + ID: "test_request_required_string_time_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31297,15 +30430,15 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringArrayArray", - OperationID: "test_request_string_array_array", + OperationName: "TestRequestRequiredStringTimeNullableArrayArray", + OperationID: "test_request_required_string_time_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]NilTime Params = struct{} Response = Error ) @@ -31318,11 +30451,11 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringArrayArray(ctx, request) + return s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -31330,23 +30463,23 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, w http return } - if err := encodeTestRequestStringArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringBinaryRequest handles test_request_string_binary operation. +// HandleTestRequestRequiredStringURIRequest handles test_request_required_string_uri operation. // -// POST /test_request_string_binary -func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri +func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary"), + otelogen.OperationID("test_request_required_string_uri"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinary", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURI", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31370,11 +30503,11 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, w http.Res } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinary", - ID: "test_request_string_binary", + Name: "TestRequestRequiredStringURI", + ID: "test_request_required_string_uri", } ) - request, close, err := s.decodeTestRequestStringBinaryRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringURIRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31394,15 +30527,15 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, w http.Res if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinary", - OperationID: "test_request_string_binary", + OperationName: "TestRequestRequiredStringURI", + OperationID: "test_request_required_string_uri", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptString + Request = url.URL Params = struct{} Response = Error ) @@ -31415,11 +30548,11 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, w http.Res mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringBinary(ctx, request) + return s.h.TestRequestRequiredStringURI(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringBinary(ctx, request) + response, err = s.h.TestRequestRequiredStringURI(ctx, request) } if err != nil { recordError("Internal", err) @@ -31427,23 +30560,23 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, w http.Res return } - if err := encodeTestRequestStringBinaryResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURIResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringBinaryArrayRequest handles test_request_string_binary_array operation. +// HandleTestRequestRequiredStringURIArrayRequest handles test_request_required_string_uri_array operation. // -// POST /test_request_string_binary_array -func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_array +func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_array"), + otelogen.OperationID("test_request_required_string_uri_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURIArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31467,11 +30600,11 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, w htt } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryArray", - ID: "test_request_string_binary_array", + Name: "TestRequestRequiredStringURIArray", + ID: "test_request_required_string_uri_array", } ) - request, close, err := s.decodeTestRequestStringBinaryArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringURIArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31491,15 +30624,15 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, w htt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryArray", - OperationID: "test_request_string_binary_array", + OperationName: "TestRequestRequiredStringURIArray", + OperationID: "test_request_required_string_uri_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []url.URL Params = struct{} Response = Error ) @@ -31512,11 +30645,11 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, w htt mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringBinaryArray(ctx, request) + return s.h.TestRequestRequiredStringURIArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringBinaryArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURIArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -31524,23 +30657,23 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, w htt return } - if err := encodeTestRequestStringBinaryArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURIArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringBinaryArrayArrayRequest handles test_request_string_binary_array_array operation. +// HandleTestRequestRequiredStringURIArrayArrayRequest handles test_request_required_string_uri_array_array operation. // -// POST /test_request_string_binary_array_array -func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_array_array +func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_array_array"), + otelogen.OperationID("test_request_required_string_uri_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURIArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31564,11 +30697,11 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryArrayArray", - ID: "test_request_string_binary_array_array", + Name: "TestRequestRequiredStringURIArrayArray", + ID: "test_request_required_string_uri_array_array", } ) - request, close, err := s.decodeTestRequestStringBinaryArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringURIArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31588,15 +30721,15 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryArrayArray", - OperationID: "test_request_string_binary_array_array", + OperationName: "TestRequestRequiredStringURIArrayArray", + OperationID: "test_request_required_string_uri_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]url.URL Params = struct{} Response = Error ) @@ -31609,11 +30742,11 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringBinaryArrayArray(ctx, request) + return s.h.TestRequestRequiredStringURIArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringBinaryArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURIArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -31621,23 +30754,23 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringBinaryArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURIArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringBinaryNullableRequest handles test_request_string_binary_nullable operation. +// HandleTestRequestRequiredStringURINullableRequest handles test_request_required_string_uri_nullable operation. // -// POST /test_request_string_binary_nullable -func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_nullable +func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable"), + otelogen.OperationID("test_request_required_string_uri_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31661,11 +30794,11 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryNullable", - ID: "test_request_string_binary_nullable", + Name: "TestRequestRequiredStringURINullable", + ID: "test_request_required_string_uri_nullable", } ) - request, close, err := s.decodeTestRequestStringBinaryNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringURINullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31685,15 +30818,15 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryNullable", - OperationID: "test_request_string_binary_nullable", + OperationName: "TestRequestRequiredStringURINullable", + OperationID: "test_request_required_string_uri_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilString + Request = NilURI Params = struct{} Response = Error ) @@ -31706,11 +30839,11 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringBinaryNullable(ctx, request) + return s.h.TestRequestRequiredStringURINullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringBinaryNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -31718,23 +30851,23 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, w return } - if err := encodeTestRequestStringBinaryNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURINullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringBinaryNullableArrayRequest handles test_request_string_binary_nullable_array operation. +// HandleTestRequestRequiredStringURINullableArrayRequest handles test_request_required_string_uri_nullable_array operation. // -// POST /test_request_string_binary_nullable_array -func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_nullable_array +func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable_array"), + otelogen.OperationID("test_request_required_string_uri_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31758,11 +30891,11 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryNullableArray", - ID: "test_request_string_binary_nullable_array", + Name: "TestRequestRequiredStringURINullableArray", + ID: "test_request_required_string_uri_nullable_array", } ) - request, close, err := s.decodeTestRequestStringBinaryNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringURINullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31782,15 +30915,15 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryNullableArray", - OperationID: "test_request_string_binary_nullable_array", + OperationName: "TestRequestRequiredStringURINullableArray", + OperationID: "test_request_required_string_uri_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []NilURI Params = struct{} Response = Error ) @@ -31803,11 +30936,11 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringBinaryNullableArray(ctx, request) + return s.h.TestRequestRequiredStringURINullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringBinaryNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -31815,23 +30948,23 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin return } - if err := encodeTestRequestStringBinaryNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURINullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringBinaryNullableArrayArrayRequest handles test_request_string_binary_nullable_array_array operation. +// HandleTestRequestRequiredStringURINullableArrayArrayRequest handles test_request_required_string_uri_nullable_array_array operation. // -// POST /test_request_string_binary_nullable_array_array -func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_nullable_array_array +func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uri_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31855,11 +30988,11 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryNullableArrayArray", - ID: "test_request_string_binary_nullable_array_array", + Name: "TestRequestRequiredStringURINullableArrayArray", + ID: "test_request_required_string_uri_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringBinaryNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringURINullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31879,15 +31012,15 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryNullableArrayArray", - OperationID: "test_request_string_binary_nullable_array_array", + OperationName: "TestRequestRequiredStringURINullableArrayArray", + OperationID: "test_request_required_string_uri_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilURI Params = struct{} Response = Error ) @@ -31900,11 +31033,11 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -31912,23 +31045,23 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURINullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringByteRequest handles test_request_string_byte operation. +// HandleTestRequestRequiredStringUUIDRequest handles test_request_required_string_uuid operation. // -// POST /test_request_string_byte -func (s *Server) handleTestRequestStringByteRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid +func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte"), + otelogen.OperationID("test_request_required_string_uuid"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByte", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUID", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -31952,11 +31085,11 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, w http.Respo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByte", - ID: "test_request_string_byte", + Name: "TestRequestRequiredStringUUID", + ID: "test_request_required_string_uuid", } ) - request, close, err := s.decodeTestRequestStringByteRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUUIDRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -31976,15 +31109,15 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, w http.Respo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByte", - OperationID: "test_request_string_byte", + OperationName: "TestRequestRequiredStringUUID", + OperationID: "test_request_required_string_uuid", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []byte + Request = uuid.UUID Params = struct{} Response = Error ) @@ -31997,11 +31130,11 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, w http.Respo mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringByte(ctx, request) + return s.h.TestRequestRequiredStringUUID(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringByte(ctx, request) + response, err = s.h.TestRequestRequiredStringUUID(ctx, request) } if err != nil { recordError("Internal", err) @@ -32009,23 +31142,23 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, w http.Respo return } - if err := encodeTestRequestStringByteResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringByteArrayRequest handles test_request_string_byte_array operation. +// HandleTestRequestRequiredStringUUIDArrayRequest handles test_request_required_string_uuid_array operation. // -// POST /test_request_string_byte_array -func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_array +func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_array"), + otelogen.OperationID("test_request_required_string_uuid_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32049,11 +31182,11 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteArray", - ID: "test_request_string_byte_array", + Name: "TestRequestRequiredStringUUIDArray", + ID: "test_request_required_string_uuid_array", } ) - request, close, err := s.decodeTestRequestStringByteArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUUIDArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32073,15 +31206,15 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteArray", - OperationID: "test_request_string_byte_array", + OperationName: "TestRequestRequiredStringUUIDArray", + OperationID: "test_request_required_string_uuid_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]byte + Request = []uuid.UUID Params = struct{} Response = Error ) @@ -32094,11 +31227,11 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringByteArray(ctx, request) + return s.h.TestRequestRequiredStringUUIDArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringByteArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -32106,23 +31239,23 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, w http. return } - if err := encodeTestRequestStringByteArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringByteArrayArrayRequest handles test_request_string_byte_array_array operation. +// HandleTestRequestRequiredStringUUIDArrayArrayRequest handles test_request_required_string_uuid_array_array operation. // -// POST /test_request_string_byte_array_array -func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_array_array +func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_array_array"), + otelogen.OperationID("test_request_required_string_uuid_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32146,11 +31279,11 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteArrayArray", - ID: "test_request_string_byte_array_array", + Name: "TestRequestRequiredStringUUIDArrayArray", + ID: "test_request_required_string_uuid_array_array", } ) - request, close, err := s.decodeTestRequestStringByteArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUUIDArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32170,15 +31303,15 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteArrayArray", - OperationID: "test_request_string_byte_array_array", + OperationName: "TestRequestRequiredStringUUIDArrayArray", + OperationID: "test_request_required_string_uuid_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]uuid.UUID Params = struct{} Response = Error ) @@ -32191,11 +31324,11 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringByteArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringByteArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -32203,23 +31336,23 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringByteArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringByteNullableRequest handles test_request_string_byte_nullable operation. +// HandleTestRequestRequiredStringUUIDNullableRequest handles test_request_required_string_uuid_nullable operation. // -// POST /test_request_string_byte_nullable -func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_nullable +func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable"), + otelogen.OperationID("test_request_required_string_uuid_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32243,11 +31376,11 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteNullable", - ID: "test_request_string_byte_nullable", + Name: "TestRequestRequiredStringUUIDNullable", + ID: "test_request_required_string_uuid_nullable", } ) - request, close, err := s.decodeTestRequestStringByteNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUUIDNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32267,15 +31400,15 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteNullable", - OperationID: "test_request_string_byte_nullable", + OperationName: "TestRequestRequiredStringUUIDNullable", + OperationID: "test_request_required_string_uuid_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilByte + Request = NilUUID Params = struct{} Response = Error ) @@ -32288,11 +31421,11 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringByteNullable(ctx, request) + return s.h.TestRequestRequiredStringUUIDNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringByteNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -32300,23 +31433,23 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, w ht return } - if err := encodeTestRequestStringByteNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringByteNullableArrayRequest handles test_request_string_byte_nullable_array operation. +// HandleTestRequestRequiredStringUUIDNullableArrayRequest handles test_request_required_string_uuid_nullable_array operation. // -// POST /test_request_string_byte_nullable_array -func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_nullable_array +func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable_array"), + otelogen.OperationID("test_request_required_string_uuid_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32340,11 +31473,11 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteNullableArray", - ID: "test_request_string_byte_nullable_array", + Name: "TestRequestRequiredStringUUIDNullableArray", + ID: "test_request_required_string_uuid_nullable_array", } ) - request, close, err := s.decodeTestRequestStringByteNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32364,15 +31497,15 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteNullableArray", - OperationID: "test_request_string_byte_nullable_array", + OperationName: "TestRequestRequiredStringUUIDNullableArray", + OperationID: "test_request_required_string_uuid_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]byte + Request = []NilUUID Params = struct{} Response = Error ) @@ -32385,11 +31518,11 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringByteNullableArray(ctx, request) + return s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringByteNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -32397,23 +31530,23 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringByteNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringByteNullableArrayArrayRequest handles test_request_string_byte_nullable_array_array operation. +// HandleTestRequestRequiredStringUUIDNullableArrayArrayRequest handles test_request_required_string_uuid_nullable_array_array operation. // -// POST /test_request_string_byte_nullable_array_array -func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uuid_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32437,11 +31570,11 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteNullableArrayArray", - ID: "test_request_string_byte_nullable_array_array", + Name: "TestRequestRequiredStringUUIDNullableArrayArray", + ID: "test_request_required_string_uuid_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringByteNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32461,15 +31594,15 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteNullableArrayArray", - OperationID: "test_request_string_byte_nullable_array_array", + OperationName: "TestRequestRequiredStringUUIDNullableArrayArray", + OperationID: "test_request_required_string_uuid_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]NilUUID Params = struct{} Response = Error ) @@ -32482,11 +31615,11 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringByteNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringByteNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -32494,23 +31627,23 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringByteNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateRequest handles test_request_string_date operation. +// HandleTestRequestRequiredStringUnixRequest handles test_request_required_string_unix operation. // -// POST /test_request_string_date -func (s *Server) handleTestRequestStringDateRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix +func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date"), + otelogen.OperationID("test_request_required_string_unix"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDate", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnix", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32534,11 +31667,11 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, w http.Respo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDate", - ID: "test_request_string_date", + Name: "TestRequestRequiredStringUnix", + ID: "test_request_required_string_unix", } ) - request, close, err := s.decodeTestRequestStringDateRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32558,15 +31691,15 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, w http.Respo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDate", - OperationID: "test_request_string_date", + OperationName: "TestRequestRequiredStringUnix", + OperationID: "test_request_required_string_unix", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptDate + Request = time.Time Params = struct{} Response = Error ) @@ -32579,11 +31712,11 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, w http.Respo mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDate(ctx, request) + return s.h.TestRequestRequiredStringUnix(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDate(ctx, request) + response, err = s.h.TestRequestRequiredStringUnix(ctx, request) } if err != nil { recordError("Internal", err) @@ -32591,23 +31724,23 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, w http.Respo return } - if err := encodeTestRequestStringDateResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateArrayRequest handles test_request_string_date_array operation. +// HandleTestRequestRequiredStringUnixArrayRequest handles test_request_required_string_unix_array operation. // -// POST /test_request_string_date_array -func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_array +func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_array"), + otelogen.OperationID("test_request_required_string_unix_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32631,11 +31764,11 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateArray", - ID: "test_request_string_date_array", + Name: "TestRequestRequiredStringUnixArray", + ID: "test_request_required_string_unix_array", } ) - request, close, err := s.decodeTestRequestStringDateArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32655,8 +31788,8 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateArray", - OperationID: "test_request_string_date_array", + OperationName: "TestRequestRequiredStringUnixArray", + OperationID: "test_request_required_string_unix_array", Body: request, Params: map[string]any{}, Raw: r, @@ -32676,11 +31809,11 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateArray(ctx, request) + return s.h.TestRequestRequiredStringUnixArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -32688,23 +31821,23 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, w http. return } - if err := encodeTestRequestStringDateArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateArrayArrayRequest handles test_request_string_date_array_array operation. +// HandleTestRequestRequiredStringUnixArrayArrayRequest handles test_request_required_string_unix_array_array operation. // -// POST /test_request_string_date_array_array -func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_array_array +func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_array_array"), + otelogen.OperationID("test_request_required_string_unix_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32728,11 +31861,11 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateArrayArray", - ID: "test_request_string_date_array_array", + Name: "TestRequestRequiredStringUnixArrayArray", + ID: "test_request_required_string_unix_array_array", } ) - request, close, err := s.decodeTestRequestStringDateArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32752,8 +31885,8 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateArrayArray", - OperationID: "test_request_string_date_array_array", + OperationName: "TestRequestRequiredStringUnixArrayArray", + OperationID: "test_request_required_string_unix_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -32773,11 +31906,11 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -32785,23 +31918,23 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringDateArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateNullableRequest handles test_request_string_date_nullable operation. +// HandleTestRequestRequiredStringUnixMicroRequest handles test_request_required_string_unix-micro operation. // -// POST /test_request_string_date_nullable -func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro +func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable"), + otelogen.OperationID("test_request_required_string_unix-micro"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicro", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32825,11 +31958,11 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateNullable", - ID: "test_request_string_date_nullable", + Name: "TestRequestRequiredStringUnixMicro", + ID: "test_request_required_string_unix-micro", } ) - request, close, err := s.decodeTestRequestStringDateNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32849,15 +31982,15 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateNullable", - OperationID: "test_request_string_date_nullable", + OperationName: "TestRequestRequiredStringUnixMicro", + OperationID: "test_request_required_string_unix-micro", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilDate + Request = time.Time Params = struct{} Response = Error ) @@ -32870,11 +32003,11 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateNullable(ctx, request) + return s.h.TestRequestRequiredStringUnixMicro(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicro(ctx, request) } if err != nil { recordError("Internal", err) @@ -32882,23 +32015,23 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, w ht return } - if err := encodeTestRequestStringDateNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateNullableArrayRequest handles test_request_string_date_nullable_array operation. +// HandleTestRequestRequiredStringUnixMicroArrayRequest handles test_request_required_string_unix-micro_array operation. // -// POST /test_request_string_date_nullable_array -func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_array +func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-micro_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -32922,11 +32055,11 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateNullableArray", - ID: "test_request_string_date_nullable_array", + Name: "TestRequestRequiredStringUnixMicroArray", + ID: "test_request_required_string_unix-micro_array", } ) - request, close, err := s.decodeTestRequestStringDateNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -32946,15 +32079,15 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateNullableArray", - OperationID: "test_request_string_date_nullable_array", + OperationName: "TestRequestRequiredStringUnixMicroArray", + OperationID: "test_request_required_string_unix-micro_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilDate + Request = []time.Time Params = struct{} Response = Error ) @@ -32967,11 +32100,11 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateNullableArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -32979,23 +32112,23 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringDateNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateNullableArrayArrayRequest handles test_request_string_date_nullable_array_array operation. +// HandleTestRequestRequiredStringUnixMicroArrayArrayRequest handles test_request_required_string_unix-micro_array_array operation. // -// POST /test_request_string_date_nullable_array_array -func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_array_array +func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-micro_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33019,11 +32152,11 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateNullableArrayArray", - ID: "test_request_string_date_nullable_array_array", + Name: "TestRequestRequiredStringUnixMicroArrayArray", + ID: "test_request_required_string_unix-micro_array_array", } ) - request, close, err := s.decodeTestRequestStringDateNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33043,15 +32176,15 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateNullableArrayArray", - OperationID: "test_request_string_date_nullable_array_array", + OperationName: "TestRequestRequiredStringUnixMicroArrayArray", + OperationID: "test_request_required_string_unix-micro_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilDate + Request = [][]time.Time Params = struct{} Response = Error ) @@ -33064,11 +32197,11 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -33076,23 +32209,23 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringDateNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateTimeRequest handles test_request_string_date-time operation. +// HandleTestRequestRequiredStringUnixMicroNullableRequest handles test_request_required_string_unix-micro_nullable operation. // -// POST /test_request_string_date-time -func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_nullable +func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time"), + otelogen.OperationID("test_request_required_string_unix-micro_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33116,11 +32249,11 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTime", - ID: "test_request_string_date-time", + Name: "TestRequestRequiredStringUnixMicroNullable", + ID: "test_request_required_string_unix-micro_nullable", } ) - request, close, err := s.decodeTestRequestStringDateTimeRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33140,15 +32273,15 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTime", - OperationID: "test_request_string_date-time", + OperationName: "TestRequestRequiredStringUnixMicroNullable", + OperationID: "test_request_required_string_unix-micro_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptDateTime + Request = NilStringUnixMicro Params = struct{} Response = Error ) @@ -33161,11 +32294,11 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateTime(ctx, request) + return s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateTime(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -33173,23 +32306,23 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, w http.R return } - if err := encodeTestRequestStringDateTimeResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateTimeArrayRequest handles test_request_string_date-time_array operation. +// HandleTestRequestRequiredStringUnixMicroNullableArrayRequest handles test_request_required_string_unix-micro_nullable_array operation. // -// POST /test_request_string_date-time_array -func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_array"), + otelogen.OperationID("test_request_required_string_unix-micro_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33213,11 +32346,11 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeArray", - ID: "test_request_string_date-time_array", + Name: "TestRequestRequiredStringUnixMicroNullableArray", + ID: "test_request_required_string_unix-micro_nullable_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33237,15 +32370,15 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeArray", - OperationID: "test_request_string_date-time_array", + OperationName: "TestRequestRequiredStringUnixMicroNullableArray", + OperationID: "test_request_required_string_unix-micro_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilStringUnixMicro Params = struct{} Response = Error ) @@ -33258,11 +32391,11 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateTimeArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateTimeArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -33270,23 +32403,23 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, w h return } - if err := encodeTestRequestStringDateTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateTimeArrayArrayRequest handles test_request_string_date-time_array_array operation. +// HandleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest handles test_request_required_string_unix-micro_nullable_array_array operation. // -// POST /test_request_string_date-time_array_array -func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_array_array"), + otelogen.OperationID("test_request_required_string_unix-micro_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33310,11 +32443,11 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeArrayArray", - ID: "test_request_string_date-time_array_array", + Name: "TestRequestRequiredStringUnixMicroNullableArrayArray", + ID: "test_request_required_string_unix-micro_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33334,15 +32467,15 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeArrayArray", - OperationID: "test_request_string_date-time_array_array", + OperationName: "TestRequestRequiredStringUnixMicroNullableArrayArray", + OperationID: "test_request_required_string_unix-micro_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilStringUnixMicro Params = struct{} Response = Error ) @@ -33355,11 +32488,11 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateTimeArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateTimeArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -33367,23 +32500,23 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringDateTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateTimeNullableRequest handles test_request_string_date-time_nullable operation. +// HandleTestRequestRequiredStringUnixMilliRequest handles test_request_required_string_unix-milli operation. // -// POST /test_request_string_date-time_nullable -func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli +func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable"), + otelogen.OperationID("test_request_required_string_unix-milli"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilli", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33407,11 +32540,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeNullable", - ID: "test_request_string_date-time_nullable", + Name: "TestRequestRequiredStringUnixMilli", + ID: "test_request_required_string_unix-milli", } ) - request, close, err := s.decodeTestRequestStringDateTimeNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33431,15 +32564,15 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeNullable", - OperationID: "test_request_string_date-time_nullable", + OperationName: "TestRequestRequiredStringUnixMilli", + OperationID: "test_request_required_string_unix-milli", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilDateTime + Request = time.Time Params = struct{} Response = Error ) @@ -33452,11 +32585,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateTimeNullable(ctx, request) + return s.h.TestRequestRequiredStringUnixMilli(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateTimeNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilli(ctx, request) } if err != nil { recordError("Internal", err) @@ -33464,23 +32597,23 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, return } - if err := encodeTestRequestStringDateTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateTimeNullableArrayRequest handles test_request_string_date-time_nullable_array operation. +// HandleTestRequestRequiredStringUnixMilliArrayRequest handles test_request_required_string_unix-milli_array operation. // -// POST /test_request_string_date-time_nullable_array -func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_array +func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-milli_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33504,11 +32637,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeNullableArray", - ID: "test_request_string_date-time_nullable_array", + Name: "TestRequestRequiredStringUnixMilliArray", + ID: "test_request_required_string_unix-milli_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33528,15 +32661,15 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeNullableArray", - OperationID: "test_request_string_date-time_nullable_array", + OperationName: "TestRequestRequiredStringUnixMilliArray", + OperationID: "test_request_required_string_unix-milli_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilDateTime + Request = []time.Time Params = struct{} Response = Error ) @@ -33549,11 +32682,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateTimeNullableArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateTimeNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -33561,23 +32694,23 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringDateTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDateTimeNullableArrayArrayRequest handles test_request_string_date-time_nullable_array_array operation. +// HandleTestRequestRequiredStringUnixMilliArrayArrayRequest handles test_request_required_string_unix-milli_array_array operation. // -// POST /test_request_string_date-time_nullable_array_array -func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_array_array +func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-milli_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33601,11 +32734,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeNullableArrayArray", - ID: "test_request_string_date-time_nullable_array_array", + Name: "TestRequestRequiredStringUnixMilliArrayArray", + ID: "test_request_required_string_unix-milli_array_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33625,15 +32758,15 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeNullableArrayArray", - OperationID: "test_request_string_date-time_nullable_array_array", + OperationName: "TestRequestRequiredStringUnixMilliArrayArray", + OperationID: "test_request_required_string_unix-milli_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilDateTime + Request = [][]time.Time Params = struct{} Response = Error ) @@ -33646,11 +32779,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -33658,23 +32791,23 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDurationRequest handles test_request_string_duration operation. +// HandleTestRequestRequiredStringUnixMilliNullableRequest handles test_request_required_string_unix-milli_nullable operation. // -// POST /test_request_string_duration -func (s *Server) handleTestRequestStringDurationRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_nullable +func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration"), + otelogen.OperationID("test_request_required_string_unix-milli_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDuration", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33698,11 +32831,11 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDuration", - ID: "test_request_string_duration", + Name: "TestRequestRequiredStringUnixMilliNullable", + ID: "test_request_required_string_unix-milli_nullable", } ) - request, close, err := s.decodeTestRequestStringDurationRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33722,15 +32855,15 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDuration", - OperationID: "test_request_string_duration", + OperationName: "TestRequestRequiredStringUnixMilliNullable", + OperationID: "test_request_required_string_unix-milli_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptDuration + Request = NilStringUnixMilli Params = struct{} Response = Error ) @@ -33743,11 +32876,11 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDuration(ctx, request) + return s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDuration(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -33755,23 +32888,23 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, w http.R return } - if err := encodeTestRequestStringDurationResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDurationArrayRequest handles test_request_string_duration_array operation. +// HandleTestRequestRequiredStringUnixMilliNullableArrayRequest handles test_request_required_string_unix-milli_nullable_array operation. // -// POST /test_request_string_duration_array -func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_array"), + otelogen.OperationID("test_request_required_string_unix-milli_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33795,11 +32928,11 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationArray", - ID: "test_request_string_duration_array", + Name: "TestRequestRequiredStringUnixMilliNullableArray", + ID: "test_request_required_string_unix-milli_nullable_array", } ) - request, close, err := s.decodeTestRequestStringDurationArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33819,15 +32952,15 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationArray", - OperationID: "test_request_string_duration_array", + OperationName: "TestRequestRequiredStringUnixMilliNullableArray", + OperationID: "test_request_required_string_unix-milli_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Duration + Request = []NilStringUnixMilli Params = struct{} Response = Error ) @@ -33840,11 +32973,11 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDurationArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDurationArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -33852,23 +32985,23 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, w h return } - if err := encodeTestRequestStringDurationArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDurationArrayArrayRequest handles test_request_string_duration_array_array operation. +// HandleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest handles test_request_required_string_unix-milli_nullable_array_array operation. // -// POST /test_request_string_duration_array_array -func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_array_array"), + otelogen.OperationID("test_request_required_string_unix-milli_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33892,11 +33025,11 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationArrayArray", - ID: "test_request_string_duration_array_array", + Name: "TestRequestRequiredStringUnixMilliNullableArrayArray", + ID: "test_request_required_string_unix-milli_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringDurationArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -33916,15 +33049,15 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationArrayArray", - OperationID: "test_request_string_duration_array_array", + OperationName: "TestRequestRequiredStringUnixMilliNullableArrayArray", + OperationID: "test_request_required_string_unix-milli_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Duration + Request = [][]NilStringUnixMilli Params = struct{} Response = Error ) @@ -33937,11 +33070,11 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDurationArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDurationArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -33949,23 +33082,23 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringDurationArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDurationNullableRequest handles test_request_string_duration_nullable operation. +// HandleTestRequestRequiredStringUnixNanoRequest handles test_request_required_string_unix-nano operation. // -// POST /test_request_string_duration_nullable -func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano +func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable"), + otelogen.OperationID("test_request_required_string_unix-nano"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNano", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -33989,11 +33122,11 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationNullable", - ID: "test_request_string_duration_nullable", + Name: "TestRequestRequiredStringUnixNano", + ID: "test_request_required_string_unix-nano", } ) - request, close, err := s.decodeTestRequestStringDurationNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34013,15 +33146,15 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationNullable", - OperationID: "test_request_string_duration_nullable", + OperationName: "TestRequestRequiredStringUnixNano", + OperationID: "test_request_required_string_unix-nano", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilDuration + Request = time.Time Params = struct{} Response = Error ) @@ -34034,11 +33167,11 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDurationNullable(ctx, request) + return s.h.TestRequestRequiredStringUnixNano(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDurationNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNano(ctx, request) } if err != nil { recordError("Internal", err) @@ -34046,23 +33179,23 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, return } - if err := encodeTestRequestStringDurationNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDurationNullableArrayRequest handles test_request_string_duration_nullable_array operation. +// HandleTestRequestRequiredStringUnixNanoArrayRequest handles test_request_required_string_unix-nano_array operation. // -// POST /test_request_string_duration_nullable_array -func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_array +func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-nano_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34086,11 +33219,11 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationNullableArray", - ID: "test_request_string_duration_nullable_array", + Name: "TestRequestRequiredStringUnixNanoArray", + ID: "test_request_required_string_unix-nano_array", } ) - request, close, err := s.decodeTestRequestStringDurationNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34110,15 +33243,15 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationNullableArray", - OperationID: "test_request_string_duration_nullable_array", + OperationName: "TestRequestRequiredStringUnixNanoArray", + OperationID: "test_request_required_string_unix-nano_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilDuration + Request = []time.Time Params = struct{} Response = Error ) @@ -34131,11 +33264,11 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDurationNullableArray(ctx, request) + return s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDurationNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -34143,23 +33276,23 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringDurationNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringDurationNullableArrayArrayRequest handles test_request_string_duration_nullable_array_array operation. +// HandleTestRequestRequiredStringUnixNanoArrayArrayRequest handles test_request_required_string_unix-nano_array_array operation. // -// POST /test_request_string_duration_nullable_array_array -func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_array_array +func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-nano_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34183,11 +33316,11 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationNullableArrayArray", - ID: "test_request_string_duration_nullable_array_array", + Name: "TestRequestRequiredStringUnixNanoArrayArray", + ID: "test_request_required_string_unix-nano_array_array", } ) - request, close, err := s.decodeTestRequestStringDurationNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34207,15 +33340,15 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationNullableArrayArray", - OperationID: "test_request_string_duration_nullable_array_array", + OperationName: "TestRequestRequiredStringUnixNanoArrayArray", + OperationID: "test_request_required_string_unix-nano_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilDuration + Request = [][]time.Time Params = struct{} Response = Error ) @@ -34228,11 +33361,11 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringDurationNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringDurationNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -34240,23 +33373,23 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringDurationNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringEmailRequest handles test_request_string_email operation. +// HandleTestRequestRequiredStringUnixNanoNullableRequest handles test_request_required_string_unix-nano_nullable operation. // -// POST /test_request_string_email -func (s *Server) handleTestRequestStringEmailRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_nullable +func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmail", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34280,11 +33413,11 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmail", - ID: "test_request_string_email", + Name: "TestRequestRequiredStringUnixNanoNullable", + ID: "test_request_required_string_unix-nano_nullable", } ) - request, close, err := s.decodeTestRequestStringEmailRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34304,15 +33437,15 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmail", - OperationID: "test_request_string_email", + OperationName: "TestRequestRequiredStringUnixNanoNullable", + OperationID: "test_request_required_string_unix-nano_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptString + Request = NilStringUnixNano Params = struct{} Response = Error ) @@ -34325,11 +33458,11 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringEmail(ctx, request) + return s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringEmail(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -34337,23 +33470,23 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, w http.Resp return } - if err := encodeTestRequestStringEmailResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringEmailArrayRequest handles test_request_string_email_array operation. +// HandleTestRequestRequiredStringUnixNanoNullableArrayRequest handles test_request_required_string_unix-nano_nullable_array operation. // -// POST /test_request_string_email_array -func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_array"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34377,11 +33510,11 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailArray", - ID: "test_request_string_email_array", + Name: "TestRequestRequiredStringUnixNanoNullableArray", + ID: "test_request_required_string_unix-nano_nullable_array", } ) - request, close, err := s.decodeTestRequestStringEmailArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34401,15 +33534,15 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailArray", - OperationID: "test_request_string_email_array", + OperationName: "TestRequestRequiredStringUnixNanoNullableArray", + OperationID: "test_request_required_string_unix-nano_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []NilStringUnixNano Params = struct{} Response = Error ) @@ -34422,11 +33555,11 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringEmailArray(ctx, request) + return s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringEmailArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -34434,23 +33567,23 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, w http return } - if err := encodeTestRequestStringEmailArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringEmailArrayArrayRequest handles test_request_string_email_array_array operation. +// HandleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest handles test_request_required_string_unix-nano_nullable_array_array operation. // -// POST /test_request_string_email_array_array -func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_array_array"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34474,11 +33607,11 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailArrayArray", - ID: "test_request_string_email_array_array", + Name: "TestRequestRequiredStringUnixNanoNullableArrayArray", + ID: "test_request_required_string_unix-nano_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringEmailArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34498,15 +33631,15 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailArrayArray", - OperationID: "test_request_string_email_array_array", + OperationName: "TestRequestRequiredStringUnixNanoNullableArrayArray", + OperationID: "test_request_required_string_unix-nano_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]NilStringUnixNano Params = struct{} Response = Error ) @@ -34519,11 +33652,11 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringEmailArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringEmailArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -34531,23 +33664,23 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringEmailArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringEmailNullableRequest handles test_request_string_email_nullable operation. +// HandleTestRequestRequiredStringUnixNullableRequest handles test_request_required_string_unix_nullable operation. // -// POST /test_request_string_email_nullable -func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_nullable +func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable"), + otelogen.OperationID("test_request_required_string_unix_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34571,11 +33704,11 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailNullable", - ID: "test_request_string_email_nullable", + Name: "TestRequestRequiredStringUnixNullable", + ID: "test_request_required_string_unix_nullable", } ) - request, close, err := s.decodeTestRequestStringEmailNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34595,15 +33728,15 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailNullable", - OperationID: "test_request_string_email_nullable", + OperationName: "TestRequestRequiredStringUnixNullable", + OperationID: "test_request_required_string_unix_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilString + Request = NilStringUnixSeconds Params = struct{} Response = Error ) @@ -34616,11 +33749,11 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringEmailNullable(ctx, request) + return s.h.TestRequestRequiredStringUnixNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringEmailNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -34628,23 +33761,23 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, w h return } - if err := encodeTestRequestStringEmailNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringEmailNullableArrayRequest handles test_request_string_email_nullable_array operation. +// HandleTestRequestRequiredStringUnixNullableArrayRequest handles test_request_required_string_unix_nullable_array operation. // -// POST /test_request_string_email_nullable_array -func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable_array"), + otelogen.OperationID("test_request_required_string_unix_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34668,11 +33801,11 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailNullableArray", - ID: "test_request_string_email_nullable_array", + Name: "TestRequestRequiredStringUnixNullableArray", + ID: "test_request_required_string_unix_nullable_array", } ) - request, close, err := s.decodeTestRequestStringEmailNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34692,15 +33825,15 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailNullableArray", - OperationID: "test_request_string_email_nullable_array", + OperationName: "TestRequestRequiredStringUnixNullableArray", + OperationID: "test_request_required_string_unix_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []NilStringUnixSeconds Params = struct{} Response = Error ) @@ -34713,11 +33846,11 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringEmailNullableArray(ctx, request) + return s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringEmailNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -34725,23 +33858,23 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringEmailNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringEmailNullableArrayArrayRequest handles test_request_string_email_nullable_array_array operation. +// HandleTestRequestRequiredStringUnixNullableArrayArrayRequest handles test_request_required_string_unix_nullable_array_array operation. // -// POST /test_request_string_email_nullable_array_array -func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34765,11 +33898,11 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailNullableArrayArray", - ID: "test_request_string_email_nullable_array_array", + Name: "TestRequestRequiredStringUnixNullableArrayArray", + ID: "test_request_required_string_unix_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringEmailNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34789,15 +33922,15 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailNullableArrayArray", - OperationID: "test_request_string_email_nullable_array_array", + OperationName: "TestRequestRequiredStringUnixNullableArrayArray", + OperationID: "test_request_required_string_unix_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilStringUnixSeconds Params = struct{} Response = Error ) @@ -34810,11 +33943,11 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringEmailNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringEmailNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -34822,23 +33955,23 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringEmailNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringHostnameRequest handles test_request_string_hostname operation. +// HandleTestRequestRequiredStringUnixSecondsRequest handles test_request_required_string_unix-seconds operation. // -// POST /test_request_string_hostname -func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds +func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname"), + otelogen.OperationID("test_request_required_string_unix-seconds"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostname", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSeconds", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34862,11 +33995,11 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostname", - ID: "test_request_string_hostname", + Name: "TestRequestRequiredStringUnixSeconds", + ID: "test_request_required_string_unix-seconds", } ) - request, close, err := s.decodeTestRequestStringHostnameRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34886,15 +34019,15 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostname", - OperationID: "test_request_string_hostname", + OperationName: "TestRequestRequiredStringUnixSeconds", + OperationID: "test_request_required_string_unix-seconds", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptString + Request = time.Time Params = struct{} Response = Error ) @@ -34907,11 +34040,11 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringHostname(ctx, request) + return s.h.TestRequestRequiredStringUnixSeconds(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringHostname(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSeconds(ctx, request) } if err != nil { recordError("Internal", err) @@ -34919,23 +34052,23 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, w http.R return } - if err := encodeTestRequestStringHostnameResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringHostnameArrayRequest handles test_request_string_hostname_array operation. +// HandleTestRequestRequiredStringUnixSecondsArrayRequest handles test_request_required_string_unix-seconds_array operation. // -// POST /test_request_string_hostname_array -func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -34959,11 +34092,11 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameArray", - ID: "test_request_string_hostname_array", + Name: "TestRequestRequiredStringUnixSecondsArray", + ID: "test_request_required_string_unix-seconds_array", } ) - request, close, err := s.decodeTestRequestStringHostnameArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -34983,15 +34116,15 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameArray", - OperationID: "test_request_string_hostname_array", + OperationName: "TestRequestRequiredStringUnixSecondsArray", + OperationID: "test_request_required_string_unix-seconds_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []string + Request = []time.Time Params = struct{} Response = Error ) @@ -35004,11 +34137,11 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringHostnameArray(ctx, request) + return s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringHostnameArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35016,23 +34149,23 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, w h return } - if err := encodeTestRequestStringHostnameArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringHostnameArrayArrayRequest handles test_request_string_hostname_array_array operation. +// HandleTestRequestRequiredStringUnixSecondsArrayArrayRequest handles test_request_required_string_unix-seconds_array_array operation. // -// POST /test_request_string_hostname_array_array -func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_array_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_array_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35056,11 +34189,11 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameArrayArray", - ID: "test_request_string_hostname_array_array", + Name: "TestRequestRequiredStringUnixSecondsArrayArray", + ID: "test_request_required_string_unix-seconds_array_array", } ) - request, close, err := s.decodeTestRequestStringHostnameArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35080,15 +34213,15 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameArrayArray", - OperationID: "test_request_string_hostname_array_array", + OperationName: "TestRequestRequiredStringUnixSecondsArrayArray", + OperationID: "test_request_required_string_unix-seconds_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]string + Request = [][]time.Time Params = struct{} Response = Error ) @@ -35101,11 +34234,11 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringHostnameArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringHostnameArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35113,23 +34246,23 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringHostnameArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringHostnameNullableRequest handles test_request_string_hostname_nullable operation. +// HandleTestRequestRequiredStringUnixSecondsNullableRequest handles test_request_required_string_unix-seconds_nullable operation. // -// POST /test_request_string_hostname_nullable -func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_nullable +func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35153,11 +34286,11 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameNullable", - ID: "test_request_string_hostname_nullable", + Name: "TestRequestRequiredStringUnixSecondsNullable", + ID: "test_request_required_string_unix-seconds_nullable", } ) - request, close, err := s.decodeTestRequestStringHostnameNullableRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35177,15 +34310,15 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameNullable", - OperationID: "test_request_string_hostname_nullable", + OperationName: "TestRequestRequiredStringUnixSecondsNullable", + OperationID: "test_request_required_string_unix-seconds_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilString + Request = NilStringUnixSeconds Params = struct{} Response = Error ) @@ -35198,11 +34331,11 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringHostnameNullable(ctx, request) + return s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringHostnameNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -35210,23 +34343,23 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, return } - if err := encodeTestRequestStringHostnameNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringHostnameNullableArrayRequest handles test_request_string_hostname_nullable_array operation. +// HandleTestRequestRequiredStringUnixSecondsNullableArrayRequest handles test_request_required_string_unix-seconds_nullable_array operation. // -// POST /test_request_string_hostname_nullable_array -func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35250,11 +34383,11 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameNullableArray", - ID: "test_request_string_hostname_nullable_array", + Name: "TestRequestRequiredStringUnixSecondsNullableArray", + ID: "test_request_required_string_unix-seconds_nullable_array", } ) - request, close, err := s.decodeTestRequestStringHostnameNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35274,15 +34407,15 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameNullableArray", - OperationID: "test_request_string_hostname_nullable_array", + OperationName: "TestRequestRequiredStringUnixSecondsNullableArray", + OperationID: "test_request_required_string_unix-seconds_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []NilStringUnixSeconds Params = struct{} Response = Error ) @@ -35295,11 +34428,11 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringHostnameNullableArray(ctx, request) + return s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringHostnameNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35307,23 +34440,23 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringHostnameNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringHostnameNullableArrayArrayRequest handles test_request_string_hostname_nullable_array_array operation. +// HandleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest handles test_request_required_string_unix-seconds_nullable_array_array operation. // -// POST /test_request_string_hostname_nullable_array_array -func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable_array_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35347,11 +34480,11 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameNullableArrayArray", - ID: "test_request_string_hostname_nullable_array_array", + Name: "TestRequestRequiredStringUnixSecondsNullableArrayArray", + ID: "test_request_required_string_unix-seconds_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringHostnameNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35371,15 +34504,15 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameNullableArrayArray", - OperationID: "test_request_string_hostname_nullable_array_array", + OperationName: "TestRequestRequiredStringUnixSecondsNullableArrayArray", + OperationID: "test_request_required_string_unix-seconds_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilStringUnixSeconds Params = struct{} Response = Error ) @@ -35392,11 +34525,11 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) + return s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35404,23 +34537,23 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIPRequest handles test_request_string_ip operation. +// HandleTestRequestStringRequest handles test_request_string operation. // -// POST /test_request_string_ip -func (s *Server) handleTestRequestStringIPRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string +func (s *Server) handleTestRequestStringRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip"), + otelogen.OperationID("test_request_string"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIP", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestString", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35444,11 +34577,11 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, w http.Respons } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIP", - ID: "test_request_string_ip", + Name: "TestRequestString", + ID: "test_request_string", } ) - request, close, err := s.decodeTestRequestStringIPRequest(r, span) + request, close, err := s.decodeTestRequestStringRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35468,15 +34601,15 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, w http.Respons if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIP", - OperationID: "test_request_string_ip", + OperationName: "TestRequestString", + OperationID: "test_request_string", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptIP + Request = OptString Params = struct{} Response = Error ) @@ -35489,11 +34622,11 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, w http.Respons mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIP(ctx, request) + return s.h.TestRequestString(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIP(ctx, request) + response, err = s.h.TestRequestString(ctx, request) } if err != nil { recordError("Internal", err) @@ -35501,23 +34634,23 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, w http.Respons return } - if err := encodeTestRequestStringIPResponse(response, w, span); err != nil { + if err := encodeTestRequestStringResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIPArrayRequest handles test_request_string_ip_array operation. +// HandleTestRequestStringArrayRequest handles test_request_string_array operation. // -// POST /test_request_string_ip_array -func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_array +func (s *Server) handleTestRequestStringArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_array"), + otelogen.OperationID("test_request_string_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35541,11 +34674,11 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, w http.Re } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPArray", - ID: "test_request_string_ip_array", + Name: "TestRequestStringArray", + ID: "test_request_string_array", } ) - request, close, err := s.decodeTestRequestStringIPArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35565,15 +34698,15 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, w http.Re if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPArray", - OperationID: "test_request_string_ip_array", + OperationName: "TestRequestStringArray", + OperationID: "test_request_string_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []netip.Addr + Request = []string Params = struct{} Response = Error ) @@ -35586,11 +34719,11 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, w http.Re mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIPArray(ctx, request) + return s.h.TestRequestStringArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIPArray(ctx, request) + response, err = s.h.TestRequestStringArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35598,23 +34731,23 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, w http.Re return } - if err := encodeTestRequestStringIPArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIPArrayArrayRequest handles test_request_string_ip_array_array operation. +// HandleTestRequestStringArrayArrayRequest handles test_request_string_array_array operation. // -// POST /test_request_string_ip_array_array -func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_array_array +func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_array_array"), + otelogen.OperationID("test_request_string_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35638,11 +34771,11 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPArrayArray", - ID: "test_request_string_ip_array_array", + Name: "TestRequestStringArrayArray", + ID: "test_request_string_array_array", } ) - request, close, err := s.decodeTestRequestStringIPArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35662,15 +34795,15 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPArrayArray", - OperationID: "test_request_string_ip_array_array", + OperationName: "TestRequestStringArrayArray", + OperationID: "test_request_string_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]string Params = struct{} Response = Error ) @@ -35683,11 +34816,11 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIPArrayArray(ctx, request) + return s.h.TestRequestStringArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIPArrayArray(ctx, request) + response, err = s.h.TestRequestStringArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35695,23 +34828,23 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, w ht return } - if err := encodeTestRequestStringIPArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIPNullableRequest handles test_request_string_ip_nullable operation. +// HandleTestRequestStringBinaryRequest handles test_request_string_binary operation. // -// POST /test_request_string_ip_nullable -func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary +func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable"), + otelogen.OperationID("test_request_string_binary"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinary", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35735,11 +34868,11 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPNullable", - ID: "test_request_string_ip_nullable", + Name: "TestRequestStringBinary", + ID: "test_request_string_binary", } ) - request, close, err := s.decodeTestRequestStringIPNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringBinaryRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35759,15 +34892,15 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPNullable", - OperationID: "test_request_string_ip_nullable", + OperationName: "TestRequestStringBinary", + OperationID: "test_request_string_binary", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilIP + Request = OptString Params = struct{} Response = Error ) @@ -35780,11 +34913,11 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIPNullable(ctx, request) + return s.h.TestRequestStringBinary(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIPNullable(ctx, request) + response, err = s.h.TestRequestStringBinary(ctx, request) } if err != nil { recordError("Internal", err) @@ -35792,23 +34925,23 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, w http return } - if err := encodeTestRequestStringIPNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIPNullableArrayRequest handles test_request_string_ip_nullable_array operation. +// HandleTestRequestStringBinaryArrayRequest handles test_request_string_binary_array operation. // -// POST /test_request_string_ip_nullable_array -func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_array +func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable_array"), + otelogen.OperationID("test_request_string_binary_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35832,11 +34965,11 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPNullableArray", - ID: "test_request_string_ip_nullable_array", + Name: "TestRequestStringBinaryArray", + ID: "test_request_string_binary_array", } ) - request, close, err := s.decodeTestRequestStringIPNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringBinaryArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35856,15 +34989,15 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPNullableArray", - OperationID: "test_request_string_ip_nullable_array", + OperationName: "TestRequestStringBinaryArray", + OperationID: "test_request_string_binary_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilIP + Request = []string Params = struct{} Response = Error ) @@ -35877,11 +35010,11 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIPNullableArray(ctx, request) + return s.h.TestRequestStringBinaryArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIPNullableArray(ctx, request) + response, err = s.h.TestRequestStringBinaryArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35889,23 +35022,23 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringIPNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIPNullableArrayArrayRequest handles test_request_string_ip_nullable_array_array operation. +// HandleTestRequestStringBinaryArrayArrayRequest handles test_request_string_binary_array_array operation. // -// POST /test_request_string_ip_nullable_array_array -func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_array_array +func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable_array_array"), + otelogen.OperationID("test_request_string_binary_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -35929,11 +35062,11 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPNullableArrayArray", - ID: "test_request_string_ip_nullable_array_array", + Name: "TestRequestStringBinaryArrayArray", + ID: "test_request_string_binary_array_array", } ) - request, close, err := s.decodeTestRequestStringIPNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringBinaryArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -35953,15 +35086,15 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPNullableArrayArray", - OperationID: "test_request_string_ip_nullable_array_array", + OperationName: "TestRequestStringBinaryArrayArray", + OperationID: "test_request_string_binary_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilIP + Request = [][]string Params = struct{} Response = Error ) @@ -35974,11 +35107,11 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIPNullableArrayArray(ctx, request) + return s.h.TestRequestStringBinaryArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIPNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringBinaryArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -35986,23 +35119,23 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri return } - if err := encodeTestRequestStringIPNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt32Request handles test_request_string_int32 operation. +// HandleTestRequestStringBinaryNullableRequest handles test_request_string_binary_nullable operation. // -// POST /test_request_string_int32 -func (s *Server) handleTestRequestStringInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_nullable +func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32"), + otelogen.OperationID("test_request_string_binary_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36026,11 +35159,11 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32", - ID: "test_request_string_int32", + Name: "TestRequestStringBinaryNullable", + ID: "test_request_string_binary_nullable", } ) - request, close, err := s.decodeTestRequestStringInt32Request(r, span) + request, close, err := s.decodeTestRequestStringBinaryNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36050,15 +35183,15 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32", - OperationID: "test_request_string_int32", + OperationName: "TestRequestStringBinaryNullable", + OperationID: "test_request_string_binary_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptStringInt32 + Request = OptNilString Params = struct{} Response = Error ) @@ -36071,11 +35204,11 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt32(ctx, request) + return s.h.TestRequestStringBinaryNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt32(ctx, request) + response, err = s.h.TestRequestStringBinaryNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -36083,23 +35216,23 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, w http.Resp return } - if err := encodeTestRequestStringInt32Response(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt32ArrayRequest handles test_request_string_int32_array operation. +// HandleTestRequestStringBinaryNullableArrayRequest handles test_request_string_binary_nullable_array operation. // -// POST /test_request_string_int32_array -func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_nullable_array +func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_array"), + otelogen.OperationID("test_request_string_binary_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36123,11 +35256,11 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32Array", - ID: "test_request_string_int32_array", + Name: "TestRequestStringBinaryNullableArray", + ID: "test_request_string_binary_nullable_array", } ) - request, close, err := s.decodeTestRequestStringInt32ArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringBinaryNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36147,15 +35280,15 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32Array", - OperationID: "test_request_string_int32_array", + OperationName: "TestRequestStringBinaryNullableArray", + OperationID: "test_request_string_binary_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int32 + Request = []NilString Params = struct{} Response = Error ) @@ -36168,11 +35301,11 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt32Array(ctx, request) + return s.h.TestRequestStringBinaryNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt32Array(ctx, request) + response, err = s.h.TestRequestStringBinaryNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -36180,23 +35313,23 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, w http return } - if err := encodeTestRequestStringInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt32ArrayArrayRequest handles test_request_string_int32_array_array operation. +// HandleTestRequestStringBinaryNullableArrayArrayRequest handles test_request_string_binary_nullable_array_array operation. // -// POST /test_request_string_int32_array_array -func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_nullable_array_array +func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_array_array"), + otelogen.OperationID("test_request_string_binary_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36220,11 +35353,11 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32ArrayArray", - ID: "test_request_string_int32_array_array", + Name: "TestRequestStringBinaryNullableArrayArray", + ID: "test_request_string_binary_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringInt32ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringBinaryNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36244,15 +35377,15 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32ArrayArray", - OperationID: "test_request_string_int32_array_array", + OperationName: "TestRequestStringBinaryNullableArrayArray", + OperationID: "test_request_string_binary_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int32 + Request = [][]NilString Params = struct{} Response = Error ) @@ -36265,11 +35398,11 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt32ArrayArray(ctx, request) + return s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt32ArrayArray(ctx, request) + response, err = s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -36277,23 +35410,23 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt32NullableRequest handles test_request_string_int32_nullable operation. +// HandleTestRequestStringByteRequest handles test_request_string_byte operation. // -// POST /test_request_string_int32_nullable -func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte +func (s *Server) handleTestRequestStringByteRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable"), + otelogen.OperationID("test_request_string_byte"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByte", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36317,11 +35450,11 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32Nullable", - ID: "test_request_string_int32_nullable", + Name: "TestRequestStringByte", + ID: "test_request_string_byte", } ) - request, close, err := s.decodeTestRequestStringInt32NullableRequest(r, span) + request, close, err := s.decodeTestRequestStringByteRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36341,15 +35474,15 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32Nullable", - OperationID: "test_request_string_int32_nullable", + OperationName: "TestRequestStringByte", + OperationID: "test_request_string_byte", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilStringInt32 + Request = []byte Params = struct{} Response = Error ) @@ -36362,11 +35495,11 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt32Nullable(ctx, request) + return s.h.TestRequestStringByte(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt32Nullable(ctx, request) + response, err = s.h.TestRequestStringByte(ctx, request) } if err != nil { recordError("Internal", err) @@ -36374,23 +35507,23 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, w h return } - if err := encodeTestRequestStringInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt32NullableArrayRequest handles test_request_string_int32_nullable_array operation. +// HandleTestRequestStringByteArrayRequest handles test_request_string_byte_array operation. // -// POST /test_request_string_int32_nullable_array -func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_array +func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable_array"), + otelogen.OperationID("test_request_string_byte_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36414,11 +35547,11 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32NullableArray", - ID: "test_request_string_int32_nullable_array", + Name: "TestRequestStringByteArray", + ID: "test_request_string_byte_array", } ) - request, close, err := s.decodeTestRequestStringInt32NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringByteArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36438,15 +35571,15 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32NullableArray", - OperationID: "test_request_string_int32_nullable_array", + OperationName: "TestRequestStringByteArray", + OperationID: "test_request_string_byte_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringInt32 + Request = [][]byte Params = struct{} Response = Error ) @@ -36459,11 +35592,11 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt32NullableArray(ctx, request) + return s.h.TestRequestStringByteArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt32NullableArray(ctx, request) + response, err = s.h.TestRequestStringByteArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -36471,23 +35604,23 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt32NullableArrayArrayRequest handles test_request_string_int32_nullable_array_array operation. +// HandleTestRequestStringByteArrayArrayRequest handles test_request_string_byte_array_array operation. // -// POST /test_request_string_int32_nullable_array_array -func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_array_array +func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable_array_array"), + otelogen.OperationID("test_request_string_byte_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36511,11 +35644,11 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32NullableArrayArray", - ID: "test_request_string_int32_nullable_array_array", + Name: "TestRequestStringByteArrayArray", + ID: "test_request_string_byte_array_array", } ) - request, close, err := s.decodeTestRequestStringInt32NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringByteArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36535,15 +35668,15 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32NullableArrayArray", - OperationID: "test_request_string_int32_nullable_array_array", + OperationName: "TestRequestStringByteArrayArray", + OperationID: "test_request_string_byte_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringInt32 + Request = [][][]byte Params = struct{} Response = Error ) @@ -36556,11 +35689,11 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt32NullableArrayArray(ctx, request) + return s.h.TestRequestStringByteArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringByteArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -36568,23 +35701,23 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt64Request handles test_request_string_int64 operation. +// HandleTestRequestStringByteNullableRequest handles test_request_string_byte_nullable operation. // -// POST /test_request_string_int64 -func (s *Server) handleTestRequestStringInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_nullable +func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64"), + otelogen.OperationID("test_request_string_byte_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36608,11 +35741,11 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64", - ID: "test_request_string_int64", + Name: "TestRequestStringByteNullable", + ID: "test_request_string_byte_nullable", } ) - request, close, err := s.decodeTestRequestStringInt64Request(r, span) + request, close, err := s.decodeTestRequestStringByteNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36632,15 +35765,15 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, w http.Resp if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64", - OperationID: "test_request_string_int64", + OperationName: "TestRequestStringByteNullable", + OperationID: "test_request_string_byte_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptStringInt64 + Request = OptNilByte Params = struct{} Response = Error ) @@ -36653,11 +35786,11 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt64(ctx, request) + return s.h.TestRequestStringByteNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt64(ctx, request) + response, err = s.h.TestRequestStringByteNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -36665,23 +35798,23 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, w http.Resp return } - if err := encodeTestRequestStringInt64Response(response, w, span); err != nil { + if err := encodeTestRequestStringByteNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt64ArrayRequest handles test_request_string_int64_array operation. +// HandleTestRequestStringByteNullableArrayRequest handles test_request_string_byte_nullable_array operation. // -// POST /test_request_string_int64_array -func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_nullable_array +func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_array"), + otelogen.OperationID("test_request_string_byte_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36705,11 +35838,11 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64Array", - ID: "test_request_string_int64_array", + Name: "TestRequestStringByteNullableArray", + ID: "test_request_string_byte_nullable_array", } ) - request, close, err := s.decodeTestRequestStringInt64ArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringByteNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36729,15 +35862,15 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, w http if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64Array", - OperationID: "test_request_string_int64_array", + OperationName: "TestRequestStringByteNullableArray", + OperationID: "test_request_string_byte_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []int64 + Request = [][]byte Params = struct{} Response = Error ) @@ -36750,11 +35883,11 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt64Array(ctx, request) + return s.h.TestRequestStringByteNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt64Array(ctx, request) + response, err = s.h.TestRequestStringByteNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -36762,23 +35895,23 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, w http return } - if err := encodeTestRequestStringInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt64ArrayArrayRequest handles test_request_string_int64_array_array operation. +// HandleTestRequestStringByteNullableArrayArrayRequest handles test_request_string_byte_nullable_array_array operation. // -// POST /test_request_string_int64_array_array -func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_nullable_array_array +func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_array_array"), + otelogen.OperationID("test_request_string_byte_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36802,11 +35935,11 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64ArrayArray", - ID: "test_request_string_int64_array_array", + Name: "TestRequestStringByteNullableArrayArray", + ID: "test_request_string_byte_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringInt64ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringByteNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36826,15 +35959,15 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64ArrayArray", - OperationID: "test_request_string_int64_array_array", + OperationName: "TestRequestStringByteNullableArrayArray", + OperationID: "test_request_string_byte_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]int64 + Request = [][][]byte Params = struct{} Response = Error ) @@ -36847,11 +35980,11 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt64ArrayArray(ctx, request) + return s.h.TestRequestStringByteNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt64ArrayArray(ctx, request) + response, err = s.h.TestRequestStringByteNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -36859,23 +35992,23 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt64NullableRequest handles test_request_string_int64_nullable operation. +// HandleTestRequestStringDateRequest handles test_request_string_date operation. // -// POST /test_request_string_int64_nullable -func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date +func (s *Server) handleTestRequestStringDateRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable"), + otelogen.OperationID("test_request_string_date"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDate", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36899,11 +36032,11 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64Nullable", - ID: "test_request_string_int64_nullable", + Name: "TestRequestStringDate", + ID: "test_request_string_date", } ) - request, close, err := s.decodeTestRequestStringInt64NullableRequest(r, span) + request, close, err := s.decodeTestRequestStringDateRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -36923,15 +36056,15 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64Nullable", - OperationID: "test_request_string_int64_nullable", + OperationName: "TestRequestStringDate", + OperationID: "test_request_string_date", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilStringInt64 + Request = OptDate Params = struct{} Response = Error ) @@ -36944,11 +36077,11 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt64Nullable(ctx, request) + return s.h.TestRequestStringDate(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt64Nullable(ctx, request) + response, err = s.h.TestRequestStringDate(ctx, request) } if err != nil { recordError("Internal", err) @@ -36956,23 +36089,23 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, w h return } - if err := encodeTestRequestStringInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt64NullableArrayRequest handles test_request_string_int64_nullable_array operation. +// HandleTestRequestStringDateArrayRequest handles test_request_string_date_array operation. // -// POST /test_request_string_int64_nullable_array -func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_array +func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable_array"), + otelogen.OperationID("test_request_string_date_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -36996,11 +36129,11 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64NullableArray", - ID: "test_request_string_int64_nullable_array", + Name: "TestRequestStringDateArray", + ID: "test_request_string_date_array", } ) - request, close, err := s.decodeTestRequestStringInt64NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37020,15 +36153,15 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64NullableArray", - OperationID: "test_request_string_int64_nullable_array", + OperationName: "TestRequestStringDateArray", + OperationID: "test_request_string_date_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringInt64 + Request = []time.Time Params = struct{} Response = Error ) @@ -37041,11 +36174,11 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt64NullableArray(ctx, request) + return s.h.TestRequestStringDateArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt64NullableArray(ctx, request) + response, err = s.h.TestRequestStringDateArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -37053,23 +36186,23 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringInt64NullableArrayArrayRequest handles test_request_string_int64_nullable_array_array operation. +// HandleTestRequestStringDateArrayArrayRequest handles test_request_string_date_array_array operation. // -// POST /test_request_string_int64_nullable_array_array -func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_array_array +func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable_array_array"), + otelogen.OperationID("test_request_string_date_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37093,11 +36226,11 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64NullableArrayArray", - ID: "test_request_string_int64_nullable_array_array", + Name: "TestRequestStringDateArrayArray", + ID: "test_request_string_date_array_array", } ) - request, close, err := s.decodeTestRequestStringInt64NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37117,15 +36250,15 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64NullableArrayArray", - OperationID: "test_request_string_int64_nullable_array_array", + OperationName: "TestRequestStringDateArrayArray", + OperationID: "test_request_string_date_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringInt64 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -37138,11 +36271,11 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringInt64NullableArrayArray(ctx, request) + return s.h.TestRequestStringDateArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringInt64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -37150,23 +36283,23 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv4Request handles test_request_string_ipv4 operation. +// HandleTestRequestStringDateNullableRequest handles test_request_string_date_nullable operation. // -// POST /test_request_string_ipv4 -func (s *Server) handleTestRequestStringIpv4Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_nullable +func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4"), + otelogen.OperationID("test_request_string_date_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37190,11 +36323,11 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, w http.Respo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4", - ID: "test_request_string_ipv4", + Name: "TestRequestStringDateNullable", + ID: "test_request_string_date_nullable", } ) - request, close, err := s.decodeTestRequestStringIpv4Request(r, span) + request, close, err := s.decodeTestRequestStringDateNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37214,15 +36347,15 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, w http.Respo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4", - OperationID: "test_request_string_ipv4", + OperationName: "TestRequestStringDateNullable", + OperationID: "test_request_string_date_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptIPv4 + Request = OptNilDate Params = struct{} Response = Error ) @@ -37235,11 +36368,11 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, w http.Respo mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv4(ctx, request) + return s.h.TestRequestStringDateNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv4(ctx, request) + response, err = s.h.TestRequestStringDateNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -37247,23 +36380,23 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, w http.Respo return } - if err := encodeTestRequestStringIpv4Response(response, w, span); err != nil { + if err := encodeTestRequestStringDateNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv4ArrayRequest handles test_request_string_ipv4_array operation. +// HandleTestRequestStringDateNullableArrayRequest handles test_request_string_date_nullable_array operation. // -// POST /test_request_string_ipv4_array -func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_nullable_array +func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_array"), + otelogen.OperationID("test_request_string_date_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37287,11 +36420,11 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4Array", - ID: "test_request_string_ipv4_array", + Name: "TestRequestStringDateNullableArray", + ID: "test_request_string_date_nullable_array", } ) - request, close, err := s.decodeTestRequestStringIpv4ArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37311,15 +36444,15 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4Array", - OperationID: "test_request_string_ipv4_array", + OperationName: "TestRequestStringDateNullableArray", + OperationID: "test_request_string_date_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []netip.Addr + Request = []NilDate Params = struct{} Response = Error ) @@ -37332,11 +36465,11 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv4Array(ctx, request) + return s.h.TestRequestStringDateNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv4Array(ctx, request) + response, err = s.h.TestRequestStringDateNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -37344,23 +36477,23 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, w http. return } - if err := encodeTestRequestStringIpv4ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv4ArrayArrayRequest handles test_request_string_ipv4_array_array operation. +// HandleTestRequestStringDateNullableArrayArrayRequest handles test_request_string_date_nullable_array_array operation. // -// POST /test_request_string_ipv4_array_array -func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_nullable_array_array +func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_array_array"), + otelogen.OperationID("test_request_string_date_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37384,11 +36517,11 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4ArrayArray", - ID: "test_request_string_ipv4_array_array", + Name: "TestRequestStringDateNullableArrayArray", + ID: "test_request_string_date_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv4ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37408,15 +36541,15 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4ArrayArray", - OperationID: "test_request_string_ipv4_array_array", + OperationName: "TestRequestStringDateNullableArrayArray", + OperationID: "test_request_string_date_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]NilDate Params = struct{} Response = Error ) @@ -37429,11 +36562,11 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv4ArrayArray(ctx, request) + return s.h.TestRequestStringDateNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv4ArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -37441,23 +36574,23 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringIpv4ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv4NullableRequest handles test_request_string_ipv4_nullable operation. +// HandleTestRequestStringDateTimeRequest handles test_request_string_date-time operation. // -// POST /test_request_string_ipv4_nullable -func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time +func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable"), + otelogen.OperationID("test_request_string_date-time"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTime", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37481,11 +36614,11 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4Nullable", - ID: "test_request_string_ipv4_nullable", + Name: "TestRequestStringDateTime", + ID: "test_request_string_date-time", } ) - request, close, err := s.decodeTestRequestStringIpv4NullableRequest(r, span) + request, close, err := s.decodeTestRequestStringDateTimeRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37505,15 +36638,15 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4Nullable", - OperationID: "test_request_string_ipv4_nullable", + OperationName: "TestRequestStringDateTime", + OperationID: "test_request_string_date-time", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilIPv4 + Request = OptDateTime Params = struct{} Response = Error ) @@ -37526,11 +36659,11 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv4Nullable(ctx, request) + return s.h.TestRequestStringDateTime(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv4Nullable(ctx, request) + response, err = s.h.TestRequestStringDateTime(ctx, request) } if err != nil { recordError("Internal", err) @@ -37538,23 +36671,23 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, w ht return } - if err := encodeTestRequestStringIpv4NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv4NullableArrayRequest handles test_request_string_ipv4_nullable_array operation. +// HandleTestRequestStringDateTimeArrayRequest handles test_request_string_date-time_array operation. // -// POST /test_request_string_ipv4_nullable_array -func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_array +func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable_array"), + otelogen.OperationID("test_request_string_date-time_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37578,11 +36711,11 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4NullableArray", - ID: "test_request_string_ipv4_nullable_array", + Name: "TestRequestStringDateTimeArray", + ID: "test_request_string_date-time_array", } ) - request, close, err := s.decodeTestRequestStringIpv4NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateTimeArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37602,15 +36735,15 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4NullableArray", - OperationID: "test_request_string_ipv4_nullable_array", + OperationName: "TestRequestStringDateTimeArray", + OperationID: "test_request_string_date-time_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilIPv4 + Request = []time.Time Params = struct{} Response = Error ) @@ -37623,11 +36756,11 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv4NullableArray(ctx, request) + return s.h.TestRequestStringDateTimeArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv4NullableArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -37635,23 +36768,23 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringIpv4NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv4NullableArrayArrayRequest handles test_request_string_ipv4_nullable_array_array operation. +// HandleTestRequestStringDateTimeArrayArrayRequest handles test_request_string_date-time_array_array operation. // -// POST /test_request_string_ipv4_nullable_array_array -func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_array_array +func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable_array_array"), + otelogen.OperationID("test_request_string_date-time_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37675,11 +36808,11 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4NullableArrayArray", - ID: "test_request_string_ipv4_nullable_array_array", + Name: "TestRequestStringDateTimeArrayArray", + ID: "test_request_string_date-time_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv4NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateTimeArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37699,15 +36832,15 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4NullableArrayArray", - OperationID: "test_request_string_ipv4_nullable_array_array", + OperationName: "TestRequestStringDateTimeArrayArray", + OperationID: "test_request_string_date-time_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilIPv4 + Request = [][]time.Time Params = struct{} Response = Error ) @@ -37720,11 +36853,11 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) + return s.h.TestRequestStringDateTimeArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -37732,23 +36865,23 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv6Request handles test_request_string_ipv6 operation. +// HandleTestRequestStringDateTimeNullableRequest handles test_request_string_date-time_nullable operation. // -// POST /test_request_string_ipv6 -func (s *Server) handleTestRequestStringIpv6Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_nullable +func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6"), + otelogen.OperationID("test_request_string_date-time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37772,11 +36905,11 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, w http.Respo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6", - ID: "test_request_string_ipv6", + Name: "TestRequestStringDateTimeNullable", + ID: "test_request_string_date-time_nullable", } ) - request, close, err := s.decodeTestRequestStringIpv6Request(r, span) + request, close, err := s.decodeTestRequestStringDateTimeNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37796,15 +36929,15 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, w http.Respo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6", - OperationID: "test_request_string_ipv6", + OperationName: "TestRequestStringDateTimeNullable", + OperationID: "test_request_string_date-time_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptIPv6 + Request = OptNilDateTime Params = struct{} Response = Error ) @@ -37817,11 +36950,11 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, w http.Respo mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv6(ctx, request) + return s.h.TestRequestStringDateTimeNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv6(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -37829,23 +36962,23 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, w http.Respo return } - if err := encodeTestRequestStringIpv6Response(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv6ArrayRequest handles test_request_string_ipv6_array operation. +// HandleTestRequestStringDateTimeNullableArrayRequest handles test_request_string_date-time_nullable_array operation. // -// POST /test_request_string_ipv6_array -func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_nullable_array +func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_array"), + otelogen.OperationID("test_request_string_date-time_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37869,11 +37002,11 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6Array", - ID: "test_request_string_ipv6_array", + Name: "TestRequestStringDateTimeNullableArray", + ID: "test_request_string_date-time_nullable_array", } ) - request, close, err := s.decodeTestRequestStringIpv6ArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateTimeNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37893,15 +37026,15 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6Array", - OperationID: "test_request_string_ipv6_array", + OperationName: "TestRequestStringDateTimeNullableArray", + OperationID: "test_request_string_date-time_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []netip.Addr + Request = []NilDateTime Params = struct{} Response = Error ) @@ -37914,11 +37047,11 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv6Array(ctx, request) + return s.h.TestRequestStringDateTimeNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv6Array(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -37926,23 +37059,23 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, w http. return } - if err := encodeTestRequestStringIpv6ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv6ArrayArrayRequest handles test_request_string_ipv6_array_array operation. +// HandleTestRequestStringDateTimeNullableArrayArrayRequest handles test_request_string_date-time_nullable_array_array operation. // -// POST /test_request_string_ipv6_array_array -func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_nullable_array_array +func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_array_array"), + otelogen.OperationID("test_request_string_date-time_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -37966,11 +37099,11 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6ArrayArray", - ID: "test_request_string_ipv6_array_array", + Name: "TestRequestStringDateTimeNullableArrayArray", + ID: "test_request_string_date-time_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv6ArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDateTimeNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -37990,15 +37123,15 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6ArrayArray", - OperationID: "test_request_string_ipv6_array_array", + OperationName: "TestRequestStringDateTimeNullableArrayArray", + OperationID: "test_request_string_date-time_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]NilDateTime Params = struct{} Response = Error ) @@ -38011,11 +37144,11 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv6ArrayArray(ctx, request) + return s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv6ArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -38023,23 +37156,23 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringIpv6ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv6NullableRequest handles test_request_string_ipv6_nullable operation. +// HandleTestRequestStringDurationRequest handles test_request_string_duration operation. // -// POST /test_request_string_ipv6_nullable -func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration +func (s *Server) handleTestRequestStringDurationRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable"), + otelogen.OperationID("test_request_string_duration"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDuration", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38063,11 +37196,11 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6Nullable", - ID: "test_request_string_ipv6_nullable", + Name: "TestRequestStringDuration", + ID: "test_request_string_duration", } ) - request, close, err := s.decodeTestRequestStringIpv6NullableRequest(r, span) + request, close, err := s.decodeTestRequestStringDurationRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38087,15 +37220,15 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6Nullable", - OperationID: "test_request_string_ipv6_nullable", + OperationName: "TestRequestStringDuration", + OperationID: "test_request_string_duration", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilIPv6 + Request = OptDuration Params = struct{} Response = Error ) @@ -38108,11 +37241,11 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv6Nullable(ctx, request) + return s.h.TestRequestStringDuration(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv6Nullable(ctx, request) + response, err = s.h.TestRequestStringDuration(ctx, request) } if err != nil { recordError("Internal", err) @@ -38120,23 +37253,23 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, w ht return } - if err := encodeTestRequestStringIpv6NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv6NullableArrayRequest handles test_request_string_ipv6_nullable_array operation. +// HandleTestRequestStringDurationArrayRequest handles test_request_string_duration_array operation. // -// POST /test_request_string_ipv6_nullable_array -func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_array +func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable_array"), + otelogen.OperationID("test_request_string_duration_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38160,11 +37293,11 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6NullableArray", - ID: "test_request_string_ipv6_nullable_array", + Name: "TestRequestStringDurationArray", + ID: "test_request_string_duration_array", } ) - request, close, err := s.decodeTestRequestStringIpv6NullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDurationArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38184,15 +37317,15 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6NullableArray", - OperationID: "test_request_string_ipv6_nullable_array", + OperationName: "TestRequestStringDurationArray", + OperationID: "test_request_string_duration_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilIPv6 + Request = []time.Duration Params = struct{} Response = Error ) @@ -38205,11 +37338,11 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv6NullableArray(ctx, request) + return s.h.TestRequestStringDurationArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv6NullableArray(ctx, request) + response, err = s.h.TestRequestStringDurationArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -38217,23 +37350,23 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringIpv6NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringIpv6NullableArrayArrayRequest handles test_request_string_ipv6_nullable_array_array operation. +// HandleTestRequestStringDurationArrayArrayRequest handles test_request_string_duration_array_array operation. // -// POST /test_request_string_ipv6_nullable_array_array -func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_array_array +func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable_array_array"), + otelogen.OperationID("test_request_string_duration_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38257,11 +37390,11 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6NullableArrayArray", - ID: "test_request_string_ipv6_nullable_array_array", + Name: "TestRequestStringDurationArrayArray", + ID: "test_request_string_duration_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv6NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDurationArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38281,15 +37414,15 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6NullableArrayArray", - OperationID: "test_request_string_ipv6_nullable_array_array", + OperationName: "TestRequestStringDurationArrayArray", + OperationID: "test_request_string_duration_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilIPv6 + Request = [][]time.Duration Params = struct{} Response = Error ) @@ -38302,11 +37435,11 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) + return s.h.TestRequestStringDurationArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDurationArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -38314,23 +37447,23 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringNullableRequest handles test_request_string_nullable operation. +// HandleTestRequestStringDurationNullableRequest handles test_request_string_duration_nullable operation. // -// POST /test_request_string_nullable -func (s *Server) handleTestRequestStringNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_nullable +func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable"), + otelogen.OperationID("test_request_string_duration_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38354,11 +37487,11 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringNullable", - ID: "test_request_string_nullable", + Name: "TestRequestStringDurationNullable", + ID: "test_request_string_duration_nullable", } ) - request, close, err := s.decodeTestRequestStringNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringDurationNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38378,15 +37511,15 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringNullable", - OperationID: "test_request_string_nullable", + OperationName: "TestRequestStringDurationNullable", + OperationID: "test_request_string_duration_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilString + Request = OptNilDuration Params = struct{} Response = Error ) @@ -38399,11 +37532,11 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringNullable(ctx, request) + return s.h.TestRequestStringDurationNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringNullable(ctx, request) + response, err = s.h.TestRequestStringDurationNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -38411,23 +37544,23 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, w http.R return } - if err := encodeTestRequestStringNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringNullableArrayRequest handles test_request_string_nullable_array operation. +// HandleTestRequestStringDurationNullableArrayRequest handles test_request_string_duration_nullable_array operation. // -// POST /test_request_string_nullable_array -func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_nullable_array +func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable_array"), + otelogen.OperationID("test_request_string_duration_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38451,11 +37584,11 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringNullableArray", - ID: "test_request_string_nullable_array", + Name: "TestRequestStringDurationNullableArray", + ID: "test_request_string_duration_nullable_array", } ) - request, close, err := s.decodeTestRequestStringNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDurationNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38475,15 +37608,15 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringNullableArray", - OperationID: "test_request_string_nullable_array", + OperationName: "TestRequestStringDurationNullableArray", + OperationID: "test_request_string_duration_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilString + Request = []NilDuration Params = struct{} Response = Error ) @@ -38496,11 +37629,11 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringNullableArray(ctx, request) + return s.h.TestRequestStringDurationNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringNullableArray(ctx, request) + response, err = s.h.TestRequestStringDurationNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -38508,23 +37641,23 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, w h return } - if err := encodeTestRequestStringNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringNullableArrayArrayRequest handles test_request_string_nullable_array_array operation. +// HandleTestRequestStringDurationNullableArrayArrayRequest handles test_request_string_duration_nullable_array_array operation. // -// POST /test_request_string_nullable_array_array -func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_nullable_array_array +func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable_array_array"), + otelogen.OperationID("test_request_string_duration_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38548,11 +37681,11 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringNullableArrayArray", - ID: "test_request_string_nullable_array_array", + Name: "TestRequestStringDurationNullableArrayArray", + ID: "test_request_string_duration_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringDurationNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38572,15 +37705,15 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringNullableArrayArray", - OperationID: "test_request_string_nullable_array_array", + OperationName: "TestRequestStringDurationNullableArrayArray", + OperationID: "test_request_string_duration_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilDuration Params = struct{} Response = Error ) @@ -38593,11 +37726,11 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringNullableArrayArray(ctx, request) + return s.h.TestRequestStringDurationNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDurationNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -38605,23 +37738,23 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringPasswordRequest handles test_request_string_password operation. +// HandleTestRequestStringEmailRequest handles test_request_string_email operation. // -// POST /test_request_string_password -func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email +func (s *Server) handleTestRequestStringEmailRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password"), + otelogen.OperationID("test_request_string_email"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPassword", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmail", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38645,11 +37778,11 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPassword", - ID: "test_request_string_password", + Name: "TestRequestStringEmail", + ID: "test_request_string_email", } ) - request, close, err := s.decodeTestRequestStringPasswordRequest(r, span) + request, close, err := s.decodeTestRequestStringEmailRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38669,8 +37802,8 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPassword", - OperationID: "test_request_string_password", + OperationName: "TestRequestStringEmail", + OperationID: "test_request_string_email", Body: request, Params: map[string]any{}, Raw: r, @@ -38690,11 +37823,11 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringPassword(ctx, request) + return s.h.TestRequestStringEmail(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringPassword(ctx, request) + response, err = s.h.TestRequestStringEmail(ctx, request) } if err != nil { recordError("Internal", err) @@ -38702,23 +37835,23 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, w http.R return } - if err := encodeTestRequestStringPasswordResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringPasswordArrayRequest handles test_request_string_password_array operation. +// HandleTestRequestStringEmailArrayRequest handles test_request_string_email_array operation. // -// POST /test_request_string_password_array -func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_array +func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_array"), + otelogen.OperationID("test_request_string_email_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38742,11 +37875,11 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordArray", - ID: "test_request_string_password_array", + Name: "TestRequestStringEmailArray", + ID: "test_request_string_email_array", } ) - request, close, err := s.decodeTestRequestStringPasswordArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringEmailArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38766,8 +37899,8 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordArray", - OperationID: "test_request_string_password_array", + OperationName: "TestRequestStringEmailArray", + OperationID: "test_request_string_email_array", Body: request, Params: map[string]any{}, Raw: r, @@ -38787,11 +37920,11 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringPasswordArray(ctx, request) + return s.h.TestRequestStringEmailArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringPasswordArray(ctx, request) + response, err = s.h.TestRequestStringEmailArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -38799,23 +37932,23 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, w h return } - if err := encodeTestRequestStringPasswordArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringPasswordArrayArrayRequest handles test_request_string_password_array_array operation. +// HandleTestRequestStringEmailArrayArrayRequest handles test_request_string_email_array_array operation. // -// POST /test_request_string_password_array_array -func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_array_array +func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_array_array"), + otelogen.OperationID("test_request_string_email_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38839,11 +37972,11 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordArrayArray", - ID: "test_request_string_password_array_array", + Name: "TestRequestStringEmailArrayArray", + ID: "test_request_string_email_array_array", } ) - request, close, err := s.decodeTestRequestStringPasswordArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringEmailArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38863,8 +37996,8 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordArrayArray", - OperationID: "test_request_string_password_array_array", + OperationName: "TestRequestStringEmailArrayArray", + OperationID: "test_request_string_email_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -38884,11 +38017,11 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringPasswordArrayArray(ctx, request) + return s.h.TestRequestStringEmailArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringPasswordArrayArray(ctx, request) + response, err = s.h.TestRequestStringEmailArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -38896,23 +38029,23 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringPasswordArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringPasswordNullableRequest handles test_request_string_password_nullable operation. +// HandleTestRequestStringEmailNullableRequest handles test_request_string_email_nullable operation. // -// POST /test_request_string_password_nullable -func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_nullable +func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable"), + otelogen.OperationID("test_request_string_email_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -38936,11 +38069,11 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordNullable", - ID: "test_request_string_password_nullable", + Name: "TestRequestStringEmailNullable", + ID: "test_request_string_email_nullable", } ) - request, close, err := s.decodeTestRequestStringPasswordNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringEmailNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -38960,8 +38093,8 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordNullable", - OperationID: "test_request_string_password_nullable", + OperationName: "TestRequestStringEmailNullable", + OperationID: "test_request_string_email_nullable", Body: request, Params: map[string]any{}, Raw: r, @@ -38981,11 +38114,11 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringPasswordNullable(ctx, request) + return s.h.TestRequestStringEmailNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringPasswordNullable(ctx, request) + response, err = s.h.TestRequestStringEmailNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -38993,23 +38126,23 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, return } - if err := encodeTestRequestStringPasswordNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringPasswordNullableArrayRequest handles test_request_string_password_nullable_array operation. +// HandleTestRequestStringEmailNullableArrayRequest handles test_request_string_email_nullable_array operation. // -// POST /test_request_string_password_nullable_array -func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_nullable_array +func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable_array"), + otelogen.OperationID("test_request_string_email_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39033,11 +38166,11 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordNullableArray", - ID: "test_request_string_password_nullable_array", + Name: "TestRequestStringEmailNullableArray", + ID: "test_request_string_email_nullable_array", } ) - request, close, err := s.decodeTestRequestStringPasswordNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringEmailNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39057,8 +38190,8 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordNullableArray", - OperationID: "test_request_string_password_nullable_array", + OperationName: "TestRequestStringEmailNullableArray", + OperationID: "test_request_string_email_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -39078,11 +38211,11 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringPasswordNullableArray(ctx, request) + return s.h.TestRequestStringEmailNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringPasswordNullableArray(ctx, request) + response, err = s.h.TestRequestStringEmailNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -39090,23 +38223,23 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringPasswordNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringPasswordNullableArrayArrayRequest handles test_request_string_password_nullable_array_array operation. +// HandleTestRequestStringEmailNullableArrayArrayRequest handles test_request_string_email_nullable_array_array operation. // -// POST /test_request_string_password_nullable_array_array -func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_nullable_array_array +func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable_array_array"), + otelogen.OperationID("test_request_string_email_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39130,11 +38263,11 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordNullableArrayArray", - ID: "test_request_string_password_nullable_array_array", + Name: "TestRequestStringEmailNullableArrayArray", + ID: "test_request_string_email_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringPasswordNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringEmailNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39154,8 +38287,8 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordNullableArrayArray", - OperationID: "test_request_string_password_nullable_array_array", + OperationName: "TestRequestStringEmailNullableArrayArray", + OperationID: "test_request_string_email_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -39175,11 +38308,11 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) + return s.h.TestRequestStringEmailNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringEmailNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -39187,23 +38320,23 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringTimeRequest handles test_request_string_time operation. +// HandleTestRequestStringHostnameRequest handles test_request_string_hostname operation. // -// POST /test_request_string_time -func (s *Server) handleTestRequestStringTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname +func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time"), + otelogen.OperationID("test_request_string_hostname"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostname", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39227,11 +38360,11 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, w http.Respo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTime", - ID: "test_request_string_time", + Name: "TestRequestStringHostname", + ID: "test_request_string_hostname", } ) - request, close, err := s.decodeTestRequestStringTimeRequest(r, span) + request, close, err := s.decodeTestRequestStringHostnameRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39251,15 +38384,15 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, w http.Respo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTime", - OperationID: "test_request_string_time", + OperationName: "TestRequestStringHostname", + OperationID: "test_request_string_hostname", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptTime + Request = OptString Params = struct{} Response = Error ) @@ -39272,11 +38405,11 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, w http.Respo mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringTime(ctx, request) + return s.h.TestRequestStringHostname(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringTime(ctx, request) + response, err = s.h.TestRequestStringHostname(ctx, request) } if err != nil { recordError("Internal", err) @@ -39284,23 +38417,23 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, w http.Respo return } - if err := encodeTestRequestStringTimeResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringTimeArrayRequest handles test_request_string_time_array operation. +// HandleTestRequestStringHostnameArrayRequest handles test_request_string_hostname_array operation. // -// POST /test_request_string_time_array -func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_array +func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_array"), + otelogen.OperationID("test_request_string_hostname_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39324,11 +38457,11 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeArray", - ID: "test_request_string_time_array", + Name: "TestRequestStringHostnameArray", + ID: "test_request_string_hostname_array", } ) - request, close, err := s.decodeTestRequestStringTimeArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringHostnameArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39348,15 +38481,15 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeArray", - OperationID: "test_request_string_time_array", + OperationName: "TestRequestStringHostnameArray", + OperationID: "test_request_string_hostname_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []string Params = struct{} Response = Error ) @@ -39369,11 +38502,11 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringTimeArray(ctx, request) + return s.h.TestRequestStringHostnameArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringTimeArray(ctx, request) + response, err = s.h.TestRequestStringHostnameArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -39381,23 +38514,23 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, w http. return } - if err := encodeTestRequestStringTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringTimeArrayArrayRequest handles test_request_string_time_array_array operation. +// HandleTestRequestStringHostnameArrayArrayRequest handles test_request_string_hostname_array_array operation. // -// POST /test_request_string_time_array_array -func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_array_array +func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_array_array"), + otelogen.OperationID("test_request_string_hostname_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39421,11 +38554,11 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeArrayArray", - ID: "test_request_string_time_array_array", + Name: "TestRequestStringHostnameArrayArray", + ID: "test_request_string_hostname_array_array", } ) - request, close, err := s.decodeTestRequestStringTimeArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringHostnameArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39445,15 +38578,15 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeArrayArray", - OperationID: "test_request_string_time_array_array", + OperationName: "TestRequestStringHostnameArrayArray", + OperationID: "test_request_string_hostname_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]string Params = struct{} Response = Error ) @@ -39466,11 +38599,11 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringTimeArrayArray(ctx, request) + return s.h.TestRequestStringHostnameArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringTimeArrayArray(ctx, request) + response, err = s.h.TestRequestStringHostnameArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -39478,23 +38611,23 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringTimeNullableRequest handles test_request_string_time_nullable operation. +// HandleTestRequestStringHostnameNullableRequest handles test_request_string_hostname_nullable operation. // -// POST /test_request_string_time_nullable -func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_nullable +func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable"), + otelogen.OperationID("test_request_string_hostname_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39518,11 +38651,11 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeNullable", - ID: "test_request_string_time_nullable", + Name: "TestRequestStringHostnameNullable", + ID: "test_request_string_hostname_nullable", } ) - request, close, err := s.decodeTestRequestStringTimeNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringHostnameNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39542,15 +38675,15 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeNullable", - OperationID: "test_request_string_time_nullable", + OperationName: "TestRequestStringHostnameNullable", + OperationID: "test_request_string_hostname_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilTime + Request = OptNilString Params = struct{} Response = Error ) @@ -39563,11 +38696,11 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringTimeNullable(ctx, request) + return s.h.TestRequestStringHostnameNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringTimeNullable(ctx, request) + response, err = s.h.TestRequestStringHostnameNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -39575,23 +38708,23 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, w ht return } - if err := encodeTestRequestStringTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringTimeNullableArrayRequest handles test_request_string_time_nullable_array operation. +// HandleTestRequestStringHostnameNullableArrayRequest handles test_request_string_hostname_nullable_array operation. // -// POST /test_request_string_time_nullable_array -func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_nullable_array +func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable_array"), + otelogen.OperationID("test_request_string_hostname_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39615,11 +38748,11 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeNullableArray", - ID: "test_request_string_time_nullable_array", + Name: "TestRequestStringHostnameNullableArray", + ID: "test_request_string_hostname_nullable_array", } ) - request, close, err := s.decodeTestRequestStringTimeNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringHostnameNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39639,15 +38772,15 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeNullableArray", - OperationID: "test_request_string_time_nullable_array", + OperationName: "TestRequestStringHostnameNullableArray", + OperationID: "test_request_string_hostname_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilTime + Request = []NilString Params = struct{} Response = Error ) @@ -39660,11 +38793,11 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringTimeNullableArray(ctx, request) + return s.h.TestRequestStringHostnameNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringTimeNullableArray(ctx, request) + response, err = s.h.TestRequestStringHostnameNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -39672,23 +38805,23 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringTimeNullableArrayArrayRequest handles test_request_string_time_nullable_array_array operation. +// HandleTestRequestStringHostnameNullableArrayArrayRequest handles test_request_string_hostname_nullable_array_array operation. // -// POST /test_request_string_time_nullable_array_array -func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_nullable_array_array +func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable_array_array"), + otelogen.OperationID("test_request_string_hostname_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39712,11 +38845,11 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeNullableArrayArray", - ID: "test_request_string_time_nullable_array_array", + Name: "TestRequestStringHostnameNullableArrayArray", + ID: "test_request_string_hostname_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringTimeNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringHostnameNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39736,15 +38869,15 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeNullableArrayArray", - OperationID: "test_request_string_time_nullable_array_array", + OperationName: "TestRequestStringHostnameNullableArrayArray", + OperationID: "test_request_string_hostname_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilTime + Request = [][]NilString Params = struct{} Response = Error ) @@ -39757,11 +38890,11 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringTimeNullableArrayArray(ctx, request) + return s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -39769,23 +38902,23 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringURIRequest handles test_request_string_uri operation. +// HandleTestRequestStringIPRequest handles test_request_string_ip operation. // -// POST /test_request_string_uri -func (s *Server) handleTestRequestStringURIRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip +func (s *Server) handleTestRequestStringIPRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri"), + otelogen.OperationID("test_request_string_ip"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURI", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIP", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39809,11 +38942,11 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, w http.Respon } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURI", - ID: "test_request_string_uri", + Name: "TestRequestStringIP", + ID: "test_request_string_ip", } ) - request, close, err := s.decodeTestRequestStringURIRequest(r, span) + request, close, err := s.decodeTestRequestStringIPRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39833,15 +38966,15 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, w http.Respon if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURI", - OperationID: "test_request_string_uri", + OperationName: "TestRequestStringIP", + OperationID: "test_request_string_ip", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptURI + Request = OptIP Params = struct{} Response = Error ) @@ -39854,11 +38987,11 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, w http.Respon mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringURI(ctx, request) + return s.h.TestRequestStringIP(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringURI(ctx, request) + response, err = s.h.TestRequestStringIP(ctx, request) } if err != nil { recordError("Internal", err) @@ -39866,23 +38999,23 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, w http.Respon return } - if err := encodeTestRequestStringURIResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringURIArrayRequest handles test_request_string_uri_array operation. +// HandleTestRequestStringIPArrayRequest handles test_request_string_ip_array operation. // -// POST /test_request_string_uri_array -func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_array +func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_array"), + otelogen.OperationID("test_request_string_ip_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURIArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -39906,11 +39039,11 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURIArray", - ID: "test_request_string_uri_array", + Name: "TestRequestStringIPArray", + ID: "test_request_string_ip_array", } ) - request, close, err := s.decodeTestRequestStringURIArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIPArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -39930,15 +39063,15 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURIArray", - OperationID: "test_request_string_uri_array", + OperationName: "TestRequestStringIPArray", + OperationID: "test_request_string_ip_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []url.URL + Request = []netip.Addr Params = struct{} Response = Error ) @@ -39951,11 +39084,11 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringURIArray(ctx, request) + return s.h.TestRequestStringIPArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringURIArray(ctx, request) + response, err = s.h.TestRequestStringIPArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -39963,23 +39096,23 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, w http.R return } - if err := encodeTestRequestStringURIArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringURIArrayArrayRequest handles test_request_string_uri_array_array operation. +// HandleTestRequestStringIPArrayArrayRequest handles test_request_string_ip_array_array operation. // -// POST /test_request_string_uri_array_array -func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_array_array +func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_array_array"), + otelogen.OperationID("test_request_string_ip_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURIArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40003,11 +39136,11 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURIArrayArray", - ID: "test_request_string_uri_array_array", + Name: "TestRequestStringIPArrayArray", + ID: "test_request_string_ip_array_array", } ) - request, close, err := s.decodeTestRequestStringURIArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIPArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40027,15 +39160,15 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURIArrayArray", - OperationID: "test_request_string_uri_array_array", + OperationName: "TestRequestStringIPArrayArray", + OperationID: "test_request_string_ip_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]url.URL + Request = [][]netip.Addr Params = struct{} Response = Error ) @@ -40048,11 +39181,11 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringURIArrayArray(ctx, request) + return s.h.TestRequestStringIPArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringURIArrayArray(ctx, request) + response, err = s.h.TestRequestStringIPArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40060,23 +39193,23 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, w h return } - if err := encodeTestRequestStringURIArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringURINullableRequest handles test_request_string_uri_nullable operation. +// HandleTestRequestStringIPNullableRequest handles test_request_string_ip_nullable operation. // -// POST /test_request_string_uri_nullable -func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_nullable +func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable"), + otelogen.OperationID("test_request_string_ip_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40100,11 +39233,11 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, w htt } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURINullable", - ID: "test_request_string_uri_nullable", + Name: "TestRequestStringIPNullable", + ID: "test_request_string_ip_nullable", } ) - request, close, err := s.decodeTestRequestStringURINullableRequest(r, span) + request, close, err := s.decodeTestRequestStringIPNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40124,15 +39257,15 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, w htt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURINullable", - OperationID: "test_request_string_uri_nullable", + OperationName: "TestRequestStringIPNullable", + OperationID: "test_request_string_ip_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilURI + Request = OptNilIP Params = struct{} Response = Error ) @@ -40145,11 +39278,11 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, w htt mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringURINullable(ctx, request) + return s.h.TestRequestStringIPNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringURINullable(ctx, request) + response, err = s.h.TestRequestStringIPNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -40157,23 +39290,23 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, w htt return } - if err := encodeTestRequestStringURINullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringURINullableArrayRequest handles test_request_string_uri_nullable_array operation. +// HandleTestRequestStringIPNullableArrayRequest handles test_request_string_ip_nullable_array operation. // -// POST /test_request_string_uri_nullable_array -func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_nullable_array +func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable_array"), + otelogen.OperationID("test_request_string_ip_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40197,11 +39330,11 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURINullableArray", - ID: "test_request_string_uri_nullable_array", + Name: "TestRequestStringIPNullableArray", + ID: "test_request_string_ip_nullable_array", } ) - request, close, err := s.decodeTestRequestStringURINullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIPNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40221,15 +39354,15 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURINullableArray", - OperationID: "test_request_string_uri_nullable_array", + OperationName: "TestRequestStringIPNullableArray", + OperationID: "test_request_string_ip_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilURI + Request = []NilIP Params = struct{} Response = Error ) @@ -40242,11 +39375,11 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringURINullableArray(ctx, request) + return s.h.TestRequestStringIPNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringURINullableArray(ctx, request) + response, err = s.h.TestRequestStringIPNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40254,23 +39387,23 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringURINullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringURINullableArrayArrayRequest handles test_request_string_uri_nullable_array_array operation. +// HandleTestRequestStringIPNullableArrayArrayRequest handles test_request_string_ip_nullable_array_array operation. // -// POST /test_request_string_uri_nullable_array_array -func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_nullable_array_array +func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable_array_array"), + otelogen.OperationID("test_request_string_ip_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40294,11 +39427,11 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURINullableArrayArray", - ID: "test_request_string_uri_nullable_array_array", + Name: "TestRequestStringIPNullableArrayArray", + ID: "test_request_string_ip_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringURINullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIPNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40318,15 +39451,15 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURINullableArrayArray", - OperationID: "test_request_string_uri_nullable_array_array", + OperationName: "TestRequestStringIPNullableArrayArray", + OperationID: "test_request_string_ip_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilURI + Request = [][]NilIP Params = struct{} Response = Error ) @@ -40339,11 +39472,11 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringURINullableArrayArray(ctx, request) + return s.h.TestRequestStringIPNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringURINullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIPNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40351,23 +39484,23 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str return } - if err := encodeTestRequestStringURINullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUUIDRequest handles test_request_string_uuid operation. +// HandleTestRequestStringInt32Request handles test_request_string_int32 operation. // -// POST /test_request_string_uuid -func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32 +func (s *Server) handleTestRequestStringInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid"), + otelogen.OperationID("test_request_string_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUID", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40391,11 +39524,11 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, w http.Respo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUID", - ID: "test_request_string_uuid", + Name: "TestRequestStringInt32", + ID: "test_request_string_int32", } ) - request, close, err := s.decodeTestRequestStringUUIDRequest(r, span) + request, close, err := s.decodeTestRequestStringInt32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40415,15 +39548,15 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, w http.Respo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUID", - OperationID: "test_request_string_uuid", + OperationName: "TestRequestStringInt32", + OperationID: "test_request_string_int32", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptUUID + Request = OptStringInt32 Params = struct{} Response = Error ) @@ -40436,11 +39569,11 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, w http.Respo mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUUID(ctx, request) + return s.h.TestRequestStringInt32(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUUID(ctx, request) + response, err = s.h.TestRequestStringInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -40448,23 +39581,23 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, w http.Respo return } - if err := encodeTestRequestStringUUIDResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUUIDArrayRequest handles test_request_string_uuid_array operation. +// HandleTestRequestStringInt32ArrayRequest handles test_request_string_int32_array operation. // -// POST /test_request_string_uuid_array -func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_array +func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_array"), + otelogen.OperationID("test_request_string_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40488,11 +39621,11 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDArray", - ID: "test_request_string_uuid_array", + Name: "TestRequestStringInt32Array", + ID: "test_request_string_int32_array", } ) - request, close, err := s.decodeTestRequestStringUUIDArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40512,15 +39645,15 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDArray", - OperationID: "test_request_string_uuid_array", + OperationName: "TestRequestStringInt32Array", + OperationID: "test_request_string_int32_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []uuid.UUID + Request = []int32 Params = struct{} Response = Error ) @@ -40533,11 +39666,11 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUUIDArray(ctx, request) + return s.h.TestRequestStringInt32Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUUIDArray(ctx, request) + response, err = s.h.TestRequestStringInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -40545,23 +39678,23 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, w http. return } - if err := encodeTestRequestStringUUIDArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUUIDArrayArrayRequest handles test_request_string_uuid_array_array operation. +// HandleTestRequestStringInt32ArrayArrayRequest handles test_request_string_int32_array_array operation. // -// POST /test_request_string_uuid_array_array -func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_array_array +func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_array_array"), + otelogen.OperationID("test_request_string_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40585,11 +39718,11 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDArrayArray", - ID: "test_request_string_uuid_array_array", + Name: "TestRequestStringInt32ArrayArray", + ID: "test_request_string_int32_array_array", } ) - request, close, err := s.decodeTestRequestStringUUIDArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40609,15 +39742,15 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDArrayArray", - OperationID: "test_request_string_uuid_array_array", + OperationName: "TestRequestStringInt32ArrayArray", + OperationID: "test_request_string_int32_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]uuid.UUID + Request = [][]int32 Params = struct{} Response = Error ) @@ -40630,11 +39763,11 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUUIDArrayArray(ctx, request) + return s.h.TestRequestStringInt32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUUIDArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40642,23 +39775,23 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringUUIDArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUUIDNullableRequest handles test_request_string_uuid_nullable operation. +// HandleTestRequestStringInt32NullableRequest handles test_request_string_int32_nullable operation. // -// POST /test_request_string_uuid_nullable -func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_nullable +func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable"), + otelogen.OperationID("test_request_string_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40682,11 +39815,11 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDNullable", - ID: "test_request_string_uuid_nullable", + Name: "TestRequestStringInt32Nullable", + ID: "test_request_string_int32_nullable", } ) - request, close, err := s.decodeTestRequestStringUUIDNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringInt32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40706,15 +39839,15 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDNullable", - OperationID: "test_request_string_uuid_nullable", + OperationName: "TestRequestStringInt32Nullable", + OperationID: "test_request_string_int32_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilUUID + Request = OptNilStringInt32 Params = struct{} Response = Error ) @@ -40727,11 +39860,11 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUUIDNullable(ctx, request) + return s.h.TestRequestStringInt32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUUIDNullable(ctx, request) + response, err = s.h.TestRequestStringInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -40739,23 +39872,23 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, w ht return } - if err := encodeTestRequestStringUUIDNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUUIDNullableArrayRequest handles test_request_string_uuid_nullable_array operation. +// HandleTestRequestStringInt32NullableArrayRequest handles test_request_string_int32_nullable_array operation. // -// POST /test_request_string_uuid_nullable_array -func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_nullable_array +func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable_array"), + otelogen.OperationID("test_request_string_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40779,11 +39912,11 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDNullableArray", - ID: "test_request_string_uuid_nullable_array", + Name: "TestRequestStringInt32NullableArray", + ID: "test_request_string_int32_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUUIDNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40803,15 +39936,15 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDNullableArray", - OperationID: "test_request_string_uuid_nullable_array", + OperationName: "TestRequestStringInt32NullableArray", + OperationID: "test_request_string_int32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilUUID + Request = []NilStringInt32 Params = struct{} Response = Error ) @@ -40824,11 +39957,11 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUUIDNullableArray(ctx, request) + return s.h.TestRequestStringInt32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUUIDNullableArray(ctx, request) + response, err = s.h.TestRequestStringInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40836,23 +39969,23 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUUIDNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUUIDNullableArrayArrayRequest handles test_request_string_uuid_nullable_array_array operation. +// HandleTestRequestStringInt32NullableArrayArrayRequest handles test_request_string_int32_nullable_array_array operation. // -// POST /test_request_string_uuid_nullable_array_array -func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_nullable_array_array +func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable_array_array"), + otelogen.OperationID("test_request_string_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40876,11 +40009,11 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDNullableArrayArray", - ID: "test_request_string_uuid_nullable_array_array", + Name: "TestRequestStringInt32NullableArrayArray", + ID: "test_request_string_int32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUUIDNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40900,15 +40033,15 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDNullableArrayArray", - OperationID: "test_request_string_uuid_nullable_array_array", + OperationName: "TestRequestStringInt32NullableArrayArray", + OperationID: "test_request_string_int32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilUUID + Request = [][]NilStringInt32 Params = struct{} Response = Error ) @@ -40921,11 +40054,11 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) + return s.h.TestRequestStringInt32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40933,23 +40066,23 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixRequest handles test_request_string_unix operation. +// HandleTestRequestStringInt64Request handles test_request_string_int64 operation. // -// POST /test_request_string_unix -func (s *Server) handleTestRequestStringUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64 +func (s *Server) handleTestRequestStringInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix"), + otelogen.OperationID("test_request_string_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnix", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -40973,11 +40106,11 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, w http.Respo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnix", - ID: "test_request_string_unix", + Name: "TestRequestStringInt64", + ID: "test_request_string_int64", } ) - request, close, err := s.decodeTestRequestStringUnixRequest(r, span) + request, close, err := s.decodeTestRequestStringInt64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40997,15 +40130,15 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, w http.Respo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnix", - OperationID: "test_request_string_unix", + OperationName: "TestRequestStringInt64", + OperationID: "test_request_string_int64", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptStringUnixSeconds + Request = OptStringInt64 Params = struct{} Response = Error ) @@ -41018,11 +40151,11 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, w http.Respo mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnix(ctx, request) + return s.h.TestRequestStringInt64(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnix(ctx, request) + response, err = s.h.TestRequestStringInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -41030,23 +40163,23 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, w http.Respo return } - if err := encodeTestRequestStringUnixResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixArrayRequest handles test_request_string_unix_array operation. +// HandleTestRequestStringInt64ArrayRequest handles test_request_string_int64_array operation. // -// POST /test_request_string_unix_array -func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_array +func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_array"), + otelogen.OperationID("test_request_string_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41070,11 +40203,11 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixArray", - ID: "test_request_string_unix_array", + Name: "TestRequestStringInt64Array", + ID: "test_request_string_int64_array", } ) - request, close, err := s.decodeTestRequestStringUnixArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41094,15 +40227,15 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixArray", - OperationID: "test_request_string_unix_array", + OperationName: "TestRequestStringInt64Array", + OperationID: "test_request_string_int64_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []int64 Params = struct{} Response = Error ) @@ -41115,11 +40248,11 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixArray(ctx, request) + return s.h.TestRequestStringInt64Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixArray(ctx, request) + response, err = s.h.TestRequestStringInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -41127,23 +40260,23 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, w http. return } - if err := encodeTestRequestStringUnixArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixArrayArrayRequest handles test_request_string_unix_array_array operation. +// HandleTestRequestStringInt64ArrayArrayRequest handles test_request_string_int64_array_array operation. // -// POST /test_request_string_unix_array_array -func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_array_array +func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_array_array"), + otelogen.OperationID("test_request_string_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41167,11 +40300,11 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixArrayArray", - ID: "test_request_string_unix_array_array", + Name: "TestRequestStringInt64ArrayArray", + ID: "test_request_string_int64_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41191,15 +40324,15 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixArrayArray", - OperationID: "test_request_string_unix_array_array", + OperationName: "TestRequestStringInt64ArrayArray", + OperationID: "test_request_string_int64_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]int64 Params = struct{} Response = Error ) @@ -41212,11 +40345,11 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixArrayArray(ctx, request) + return s.h.TestRequestStringInt64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41224,23 +40357,23 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringUnixArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMicroRequest handles test_request_string_unix-micro operation. +// HandleTestRequestStringInt64NullableRequest handles test_request_string_int64_nullable operation. // -// POST /test_request_string_unix-micro -func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_nullable +func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro"), + otelogen.OperationID("test_request_string_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicro", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41264,11 +40397,11 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicro", - ID: "test_request_string_unix-micro", + Name: "TestRequestStringInt64Nullable", + ID: "test_request_string_int64_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixMicroRequest(r, span) + request, close, err := s.decodeTestRequestStringInt64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41288,15 +40421,15 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicro", - OperationID: "test_request_string_unix-micro", + OperationName: "TestRequestStringInt64Nullable", + OperationID: "test_request_string_int64_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptStringUnixMicro + Request = OptNilStringInt64 Params = struct{} Response = Error ) @@ -41309,11 +40442,11 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMicro(ctx, request) + return s.h.TestRequestStringInt64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMicro(ctx, request) + response, err = s.h.TestRequestStringInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -41321,23 +40454,23 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, w http. return } - if err := encodeTestRequestStringUnixMicroResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMicroArrayRequest handles test_request_string_unix-micro_array operation. +// HandleTestRequestStringInt64NullableArrayRequest handles test_request_string_int64_nullable_array operation. // -// POST /test_request_string_unix-micro_array -func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_nullable_array +func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_array"), + otelogen.OperationID("test_request_string_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41361,11 +40494,11 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroArray", - ID: "test_request_string_unix-micro_array", + Name: "TestRequestStringInt64NullableArray", + ID: "test_request_string_int64_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41385,15 +40518,15 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroArray", - OperationID: "test_request_string_unix-micro_array", + OperationName: "TestRequestStringInt64NullableArray", + OperationID: "test_request_string_int64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilStringInt64 Params = struct{} Response = Error ) @@ -41406,11 +40539,11 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMicroArray(ctx, request) + return s.h.TestRequestStringInt64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMicroArray(ctx, request) + response, err = s.h.TestRequestStringInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41418,23 +40551,23 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringUnixMicroArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMicroArrayArrayRequest handles test_request_string_unix-micro_array_array operation. +// HandleTestRequestStringInt64NullableArrayArrayRequest handles test_request_string_int64_nullable_array_array operation. // -// POST /test_request_string_unix-micro_array_array -func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_nullable_array_array +func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_array_array"), + otelogen.OperationID("test_request_string_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41458,11 +40591,11 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroArrayArray", - ID: "test_request_string_unix-micro_array_array", + Name: "TestRequestStringInt64NullableArrayArray", + ID: "test_request_string_int64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringInt64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41482,15 +40615,15 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroArrayArray", - OperationID: "test_request_string_unix-micro_array_array", + OperationName: "TestRequestStringInt64NullableArrayArray", + OperationID: "test_request_string_int64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilStringInt64 Params = struct{} Response = Error ) @@ -41503,11 +40636,11 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMicroArrayArray(ctx, request) + return s.h.TestRequestStringInt64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41515,23 +40648,23 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin return } - if err := encodeTestRequestStringUnixMicroArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMicroNullableRequest handles test_request_string_unix-micro_nullable operation. +// HandleTestRequestStringIpv4Request handles test_request_string_ipv4 operation. // -// POST /test_request_string_unix-micro_nullable -func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4 +func (s *Server) handleTestRequestStringIpv4Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable"), + otelogen.OperationID("test_request_string_ipv4"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41555,11 +40688,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroNullable", - ID: "test_request_string_unix-micro_nullable", + Name: "TestRequestStringIpv4", + ID: "test_request_string_ipv4", } ) - request, close, err := s.decodeTestRequestStringUnixMicroNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv4Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41579,15 +40712,15 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroNullable", - OperationID: "test_request_string_unix-micro_nullable", + OperationName: "TestRequestStringIpv4", + OperationID: "test_request_string_ipv4", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilStringUnixMicro + Request = OptIPv4 Params = struct{} Response = Error ) @@ -41600,11 +40733,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMicroNullable(ctx, request) + return s.h.TestRequestStringIpv4(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestStringIpv4(ctx, request) } if err != nil { recordError("Internal", err) @@ -41612,23 +40745,23 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, return } - if err := encodeTestRequestStringUnixMicroNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMicroNullableArrayRequest handles test_request_string_unix-micro_nullable_array operation. +// HandleTestRequestStringIpv4ArrayRequest handles test_request_string_ipv4_array operation. // -// POST /test_request_string_unix-micro_nullable_array -func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_array +func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable_array"), + otelogen.OperationID("test_request_string_ipv4_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41652,11 +40785,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroNullableArray", - ID: "test_request_string_unix-micro_nullable_array", + Name: "TestRequestStringIpv4Array", + ID: "test_request_string_ipv4_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv4ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41676,15 +40809,15 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroNullableArray", - OperationID: "test_request_string_unix-micro_nullable_array", + OperationName: "TestRequestStringIpv4Array", + OperationID: "test_request_string_ipv4_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixMicro + Request = []netip.Addr Params = struct{} Response = Error ) @@ -41697,11 +40830,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMicroNullableArray(ctx, request) + return s.h.TestRequestStringIpv4Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestStringIpv4Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -41709,23 +40842,23 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st return } - if err := encodeTestRequestStringUnixMicroNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMicroNullableArrayArrayRequest handles test_request_string_unix-micro_nullable_array_array operation. +// HandleTestRequestStringIpv4ArrayArrayRequest handles test_request_string_ipv4_array_array operation. // -// POST /test_request_string_unix-micro_nullable_array_array -func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_array_array +func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_string_ipv4_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41749,11 +40882,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroNullableArrayArray", - ID: "test_request_string_unix-micro_nullable_array_array", + Name: "TestRequestStringIpv4ArrayArray", + ID: "test_request_string_ipv4_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv4ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41773,15 +40906,15 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroNullableArrayArray", - OperationID: "test_request_string_unix-micro_nullable_array_array", + OperationName: "TestRequestStringIpv4ArrayArray", + OperationID: "test_request_string_ipv4_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixMicro + Request = [][]netip.Addr Params = struct{} Response = Error ) @@ -41794,11 +40927,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) + return s.h.TestRequestStringIpv4ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv4ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41806,23 +40939,23 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args return } - if err := encodeTestRequestStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMilliRequest handles test_request_string_unix-milli operation. +// HandleTestRequestStringIpv4NullableRequest handles test_request_string_ipv4_nullable operation. // -// POST /test_request_string_unix-milli -func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_nullable +func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli"), + otelogen.OperationID("test_request_string_ipv4_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilli", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41846,11 +40979,11 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, w http. } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilli", - ID: "test_request_string_unix-milli", + Name: "TestRequestStringIpv4Nullable", + ID: "test_request_string_ipv4_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixMilliRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv4NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41870,15 +41003,15 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, w http. if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilli", - OperationID: "test_request_string_unix-milli", + OperationName: "TestRequestStringIpv4Nullable", + OperationID: "test_request_string_ipv4_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptStringUnixMilli + Request = OptNilIPv4 Params = struct{} Response = Error ) @@ -41891,11 +41024,11 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, w http. mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMilli(ctx, request) + return s.h.TestRequestStringIpv4Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMilli(ctx, request) + response, err = s.h.TestRequestStringIpv4Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -41903,23 +41036,23 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, w http. return } - if err := encodeTestRequestStringUnixMilliResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMilliArrayRequest handles test_request_string_unix-milli_array operation. +// HandleTestRequestStringIpv4NullableArrayRequest handles test_request_string_ipv4_nullable_array operation. // -// POST /test_request_string_unix-milli_array -func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_nullable_array +func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_array"), + otelogen.OperationID("test_request_string_ipv4_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -41943,11 +41076,11 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliArray", - ID: "test_request_string_unix-milli_array", + Name: "TestRequestStringIpv4NullableArray", + ID: "test_request_string_ipv4_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv4NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41967,15 +41100,15 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, w if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliArray", - OperationID: "test_request_string_unix-milli_array", + OperationName: "TestRequestStringIpv4NullableArray", + OperationID: "test_request_string_ipv4_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilIPv4 Params = struct{} Response = Error ) @@ -41988,11 +41121,11 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMilliArray(ctx, request) + return s.h.TestRequestStringIpv4NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMilliArray(ctx, request) + response, err = s.h.TestRequestStringIpv4NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42000,23 +41133,23 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, w return } - if err := encodeTestRequestStringUnixMilliArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMilliArrayArrayRequest handles test_request_string_unix-milli_array_array operation. +// HandleTestRequestStringIpv4NullableArrayArrayRequest handles test_request_string_ipv4_nullable_array_array operation. // -// POST /test_request_string_unix-milli_array_array -func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_nullable_array_array +func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_array_array"), + otelogen.OperationID("test_request_string_ipv4_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42040,11 +41173,11 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliArrayArray", - ID: "test_request_string_unix-milli_array_array", + Name: "TestRequestStringIpv4NullableArrayArray", + ID: "test_request_string_ipv4_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv4NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42064,15 +41197,15 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliArrayArray", - OperationID: "test_request_string_unix-milli_array_array", + OperationName: "TestRequestStringIpv4NullableArrayArray", + OperationID: "test_request_string_ipv4_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilIPv4 Params = struct{} Response = Error ) @@ -42085,11 +41218,11 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMilliArrayArray(ctx, request) + return s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42097,23 +41230,23 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin return } - if err := encodeTestRequestStringUnixMilliArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMilliNullableRequest handles test_request_string_unix-milli_nullable operation. +// HandleTestRequestStringIpv6Request handles test_request_string_ipv6 operation. // -// POST /test_request_string_unix-milli_nullable -func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6 +func (s *Server) handleTestRequestStringIpv6Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable"), + otelogen.OperationID("test_request_string_ipv6"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42137,11 +41270,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliNullable", - ID: "test_request_string_unix-milli_nullable", + Name: "TestRequestStringIpv6", + ID: "test_request_string_ipv6", } ) - request, close, err := s.decodeTestRequestStringUnixMilliNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv6Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42161,15 +41294,15 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliNullable", - OperationID: "test_request_string_unix-milli_nullable", + OperationName: "TestRequestStringIpv6", + OperationID: "test_request_string_ipv6", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilStringUnixMilli + Request = OptIPv6 Params = struct{} Response = Error ) @@ -42182,11 +41315,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMilliNullable(ctx, request) + return s.h.TestRequestStringIpv6(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestStringIpv6(ctx, request) } if err != nil { recordError("Internal", err) @@ -42194,23 +41327,23 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, return } - if err := encodeTestRequestStringUnixMilliNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMilliNullableArrayRequest handles test_request_string_unix-milli_nullable_array operation. +// HandleTestRequestStringIpv6ArrayRequest handles test_request_string_ipv6_array operation. // -// POST /test_request_string_unix-milli_nullable_array -func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_array +func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable_array"), + otelogen.OperationID("test_request_string_ipv6_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42234,11 +41367,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliNullableArray", - ID: "test_request_string_unix-milli_nullable_array", + Name: "TestRequestStringIpv6Array", + ID: "test_request_string_ipv6_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv6ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42258,15 +41391,15 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliNullableArray", - OperationID: "test_request_string_unix-milli_nullable_array", + OperationName: "TestRequestStringIpv6Array", + OperationID: "test_request_string_ipv6_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixMilli + Request = []netip.Addr Params = struct{} Response = Error ) @@ -42279,11 +41412,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMilliNullableArray(ctx, request) + return s.h.TestRequestStringIpv6Array(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestStringIpv6Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -42291,23 +41424,23 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st return } - if err := encodeTestRequestStringUnixMilliNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixMilliNullableArrayArrayRequest handles test_request_string_unix-milli_nullable_array_array operation. +// HandleTestRequestStringIpv6ArrayArrayRequest handles test_request_string_ipv6_array_array operation. // -// POST /test_request_string_unix-milli_nullable_array_array -func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_array_array +func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_string_ipv6_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42331,11 +41464,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliNullableArrayArray", - ID: "test_request_string_unix-milli_nullable_array_array", + Name: "TestRequestStringIpv6ArrayArray", + ID: "test_request_string_ipv6_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv6ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42355,15 +41488,15 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliNullableArrayArray", - OperationID: "test_request_string_unix-milli_nullable_array_array", + OperationName: "TestRequestStringIpv6ArrayArray", + OperationID: "test_request_string_ipv6_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixMilli + Request = [][]netip.Addr Params = struct{} Response = Error ) @@ -42376,11 +41509,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) + return s.h.TestRequestStringIpv6ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv6ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42388,23 +41521,23 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args return } - if err := encodeTestRequestStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNanoRequest handles test_request_string_unix-nano operation. +// HandleTestRequestStringIpv6NullableRequest handles test_request_string_ipv6_nullable operation. // -// POST /test_request_string_unix-nano -func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_nullable +func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano"), + otelogen.OperationID("test_request_string_ipv6_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNano", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42428,11 +41561,11 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, w http.R } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNano", - ID: "test_request_string_unix-nano", + Name: "TestRequestStringIpv6Nullable", + ID: "test_request_string_ipv6_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixNanoRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv6NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42452,15 +41585,15 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, w http.R if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNano", - OperationID: "test_request_string_unix-nano", + OperationName: "TestRequestStringIpv6Nullable", + OperationID: "test_request_string_ipv6_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptStringUnixNano + Request = OptNilIPv6 Params = struct{} Response = Error ) @@ -42473,11 +41606,11 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, w http.R mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNano(ctx, request) + return s.h.TestRequestStringIpv6Nullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNano(ctx, request) + response, err = s.h.TestRequestStringIpv6Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -42485,23 +41618,23 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, w http.R return } - if err := encodeTestRequestStringUnixNanoResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNanoArrayRequest handles test_request_string_unix-nano_array operation. +// HandleTestRequestStringIpv6NullableArrayRequest handles test_request_string_ipv6_nullable_array operation. // -// POST /test_request_string_unix-nano_array -func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_nullable_array +func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_array"), + otelogen.OperationID("test_request_string_ipv6_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42525,11 +41658,11 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, w h } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoArray", - ID: "test_request_string_unix-nano_array", + Name: "TestRequestStringIpv6NullableArray", + ID: "test_request_string_ipv6_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv6NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42549,15 +41682,15 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, w h if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoArray", - OperationID: "test_request_string_unix-nano_array", + OperationName: "TestRequestStringIpv6NullableArray", + OperationID: "test_request_string_ipv6_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilIPv6 Params = struct{} Response = Error ) @@ -42570,11 +41703,11 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, w h mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNanoArray(ctx, request) + return s.h.TestRequestStringIpv6NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNanoArray(ctx, request) + response, err = s.h.TestRequestStringIpv6NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42582,23 +41715,23 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, w h return } - if err := encodeTestRequestStringUnixNanoArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNanoArrayArrayRequest handles test_request_string_unix-nano_array_array operation. +// HandleTestRequestStringIpv6NullableArrayArrayRequest handles test_request_string_ipv6_nullable_array_array operation. // -// POST /test_request_string_unix-nano_array_array -func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_nullable_array_array +func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_array_array"), + otelogen.OperationID("test_request_string_ipv6_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42622,11 +41755,11 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoArrayArray", - ID: "test_request_string_unix-nano_array_array", + Name: "TestRequestStringIpv6NullableArrayArray", + ID: "test_request_string_ipv6_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringIpv6NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42646,15 +41779,15 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoArrayArray", - OperationID: "test_request_string_unix-nano_array_array", + OperationName: "TestRequestStringIpv6NullableArrayArray", + OperationID: "test_request_string_ipv6_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilIPv6 Params = struct{} Response = Error ) @@ -42667,11 +41800,11 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNanoArrayArray(ctx, request) + return s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42679,23 +41812,23 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringUnixNanoArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNanoNullableRequest handles test_request_string_unix-nano_nullable operation. +// HandleTestRequestStringNullableRequest handles test_request_string_nullable operation. // -// POST /test_request_string_unix-nano_nullable -func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_nullable +func (s *Server) handleTestRequestStringNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable"), + otelogen.OperationID("test_request_string_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42719,11 +41852,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoNullable", - ID: "test_request_string_unix-nano_nullable", + Name: "TestRequestStringNullable", + ID: "test_request_string_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixNanoNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42743,15 +41876,15 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoNullable", - OperationID: "test_request_string_unix-nano_nullable", + OperationName: "TestRequestStringNullable", + OperationID: "test_request_string_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilStringUnixNano + Request = OptNilString Params = struct{} Response = Error ) @@ -42764,11 +41897,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNanoNullable(ctx, request) + return s.h.TestRequestStringNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNanoNullable(ctx, request) + response, err = s.h.TestRequestStringNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -42776,23 +41909,23 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, return } - if err := encodeTestRequestStringUnixNanoNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNanoNullableArrayRequest handles test_request_string_unix-nano_nullable_array operation. +// HandleTestRequestStringNullableArrayRequest handles test_request_string_nullable_array operation. // -// POST /test_request_string_unix-nano_nullable_array -func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_nullable_array +func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable_array"), + otelogen.OperationID("test_request_string_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42816,11 +41949,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoNullableArray", - ID: "test_request_string_unix-nano_nullable_array", + Name: "TestRequestStringNullableArray", + ID: "test_request_string_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42840,15 +41973,15 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoNullableArray", - OperationID: "test_request_string_unix-nano_nullable_array", + OperationName: "TestRequestStringNullableArray", + OperationID: "test_request_string_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixNano + Request = []NilString Params = struct{} Response = Error ) @@ -42861,11 +41994,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNanoNullableArray(ctx, request) + return s.h.TestRequestStringNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestStringNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42873,23 +42006,23 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringUnixNanoNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNanoNullableArrayArrayRequest handles test_request_string_unix-nano_nullable_array_array operation. +// HandleTestRequestStringNullableArrayArrayRequest handles test_request_string_nullable_array_array operation. // -// POST /test_request_string_unix-nano_nullable_array_array -func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_nullable_array_array +func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_string_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -42913,11 +42046,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoNullableArrayArray", - ID: "test_request_string_unix-nano_nullable_array_array", + Name: "TestRequestStringNullableArrayArray", + ID: "test_request_string_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42937,15 +42070,15 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoNullableArrayArray", - OperationID: "test_request_string_unix-nano_nullable_array_array", + OperationName: "TestRequestStringNullableArrayArray", + OperationID: "test_request_string_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixNano + Request = [][]NilString Params = struct{} Response = Error ) @@ -42958,11 +42091,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) + return s.h.TestRequestStringNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42970,23 +42103,23 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNullableRequest handles test_request_string_unix_nullable operation. +// HandleTestRequestStringPasswordRequest handles test_request_string_password operation. // -// POST /test_request_string_unix_nullable -func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password +func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable"), + otelogen.OperationID("test_request_string_password"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPassword", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43010,11 +42143,11 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNullable", - ID: "test_request_string_unix_nullable", + Name: "TestRequestStringPassword", + ID: "test_request_string_password", } ) - request, close, err := s.decodeTestRequestStringUnixNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringPasswordRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43034,15 +42167,15 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, w ht if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNullable", - OperationID: "test_request_string_unix_nullable", + OperationName: "TestRequestStringPassword", + OperationID: "test_request_string_password", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilStringUnixSeconds + Request = OptString Params = struct{} Response = Error ) @@ -43055,11 +42188,11 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNullable(ctx, request) + return s.h.TestRequestStringPassword(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNullable(ctx, request) + response, err = s.h.TestRequestStringPassword(ctx, request) } if err != nil { recordError("Internal", err) @@ -43067,23 +42200,23 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, w ht return } - if err := encodeTestRequestStringUnixNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNullableArrayRequest handles test_request_string_unix_nullable_array operation. +// HandleTestRequestStringPasswordArrayRequest handles test_request_string_password_array operation. // -// POST /test_request_string_unix_nullable_array -func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_array +func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable_array"), + otelogen.OperationID("test_request_string_password_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43107,11 +42240,11 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNullableArray", - ID: "test_request_string_unix_nullable_array", + Name: "TestRequestStringPasswordArray", + ID: "test_request_string_password_array", } ) - request, close, err := s.decodeTestRequestStringUnixNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringPasswordArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43131,15 +42264,15 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNullableArray", - OperationID: "test_request_string_unix_nullable_array", + OperationName: "TestRequestStringPasswordArray", + OperationID: "test_request_string_password_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixSeconds + Request = []string Params = struct{} Response = Error ) @@ -43152,11 +42285,11 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNullableArray(ctx, request) + return s.h.TestRequestStringPasswordArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNullableArray(ctx, request) + response, err = s.h.TestRequestStringPasswordArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43164,23 +42297,23 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUnixNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixNullableArrayArrayRequest handles test_request_string_unix_nullable_array_array operation. +// HandleTestRequestStringPasswordArrayArrayRequest handles test_request_string_password_array_array operation. // -// POST /test_request_string_unix_nullable_array_array -func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_array_array +func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable_array_array"), + otelogen.OperationID("test_request_string_password_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43204,11 +42337,11 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNullableArrayArray", - ID: "test_request_string_unix_nullable_array_array", + Name: "TestRequestStringPasswordArrayArray", + ID: "test_request_string_password_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringPasswordArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43228,15 +42361,15 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNullableArrayArray", - OperationID: "test_request_string_unix_nullable_array_array", + OperationName: "TestRequestStringPasswordArrayArray", + OperationID: "test_request_string_password_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixSeconds + Request = [][]string Params = struct{} Response = Error ) @@ -43249,11 +42382,11 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixNullableArrayArray(ctx, request) + return s.h.TestRequestStringPasswordArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringPasswordArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43261,23 +42394,23 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringUnixNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixSecondsRequest handles test_request_string_unix-seconds operation. +// HandleTestRequestStringPasswordNullableRequest handles test_request_string_password_nullable operation. // -// POST /test_request_string_unix-seconds -func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_nullable +func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds"), + otelogen.OperationID("test_request_string_password_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSeconds", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43301,11 +42434,11 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, w htt } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSeconds", - ID: "test_request_string_unix-seconds", + Name: "TestRequestStringPasswordNullable", + ID: "test_request_string_password_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsRequest(r, span) + request, close, err := s.decodeTestRequestStringPasswordNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43325,15 +42458,15 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, w htt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSeconds", - OperationID: "test_request_string_unix-seconds", + OperationName: "TestRequestStringPasswordNullable", + OperationID: "test_request_string_password_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptStringUnixSeconds + Request = OptNilString Params = struct{} Response = Error ) @@ -43346,11 +42479,11 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, w htt mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixSeconds(ctx, request) + return s.h.TestRequestStringPasswordNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixSeconds(ctx, request) + response, err = s.h.TestRequestStringPasswordNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -43358,23 +42491,23 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, w htt return } - if err := encodeTestRequestStringUnixSecondsResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixSecondsArrayRequest handles test_request_string_unix-seconds_array operation. +// HandleTestRequestStringPasswordNullableArrayRequest handles test_request_string_password_nullable_array operation. // -// POST /test_request_string_unix-seconds_array -func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_nullable_array +func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_array"), + otelogen.OperationID("test_request_string_password_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43398,11 +42531,11 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsArray", - ID: "test_request_string_unix-seconds_array", + Name: "TestRequestStringPasswordNullableArray", + ID: "test_request_string_password_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringPasswordNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43422,15 +42555,15 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsArray", - OperationID: "test_request_string_unix-seconds_array", + OperationName: "TestRequestStringPasswordNullableArray", + OperationID: "test_request_string_password_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []time.Time + Request = []NilString Params = struct{} Response = Error ) @@ -43443,11 +42576,11 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixSecondsArray(ctx, request) + return s.h.TestRequestStringPasswordNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsArray(ctx, request) + response, err = s.h.TestRequestStringPasswordNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43455,23 +42588,23 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUnixSecondsArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixSecondsArrayArrayRequest handles test_request_string_unix-seconds_array_array operation. +// HandleTestRequestStringPasswordNullableArrayArrayRequest handles test_request_string_password_nullable_array_array operation. // -// POST /test_request_string_unix-seconds_array_array -func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_nullable_array_array +func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_array_array"), + otelogen.OperationID("test_request_string_password_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43495,11 +42628,11 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsArrayArray", - ID: "test_request_string_unix-seconds_array_array", + Name: "TestRequestStringPasswordNullableArrayArray", + ID: "test_request_string_password_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringPasswordNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43519,8 +42652,299 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsArrayArray", - OperationID: "test_request_string_unix-seconds_array_array", + OperationName: "TestRequestStringPasswordNullableArrayArray", + OperationID: "test_request_string_password_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilString + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringTimeRequest handles test_request_string_time operation. +// +// POST /test_request_string_time +func (s *Server) handleTestRequestStringTimeRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_time"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTime", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringTime", + ID: "test_request_string_time", + } + ) + request, close, err := s.decodeTestRequestStringTimeRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringTime", + OperationID: "test_request_string_time", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptTime + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringTime(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringTime(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringTimeResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringTimeArrayRequest handles test_request_string_time_array operation. +// +// POST /test_request_string_time_array +func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_time_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringTimeArray", + ID: "test_request_string_time_array", + } + ) + request, close, err := s.decodeTestRequestStringTimeArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringTimeArray", + OperationID: "test_request_string_time_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringTimeArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringTimeArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringTimeArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringTimeArrayArrayRequest handles test_request_string_time_array_array operation. +// +// POST /test_request_string_time_array_array +func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_time_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringTimeArrayArray", + ID: "test_request_string_time_array_array", + } + ) + request, close, err := s.decodeTestRequestStringTimeArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringTimeArrayArray", + OperationID: "test_request_string_time_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -43540,11 +42964,11 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) + return s.h.TestRequestStringTimeArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestStringTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43552,23 +42976,23 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str return } - if err := encodeTestRequestStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixSecondsNullableRequest handles test_request_string_unix-seconds_nullable operation. +// HandleTestRequestStringTimeNullableRequest handles test_request_string_time_nullable operation. // -// POST /test_request_string_unix-seconds_nullable -func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_nullable +func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable"), + otelogen.OperationID("test_request_string_time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43592,11 +43016,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsNullable", - ID: "test_request_string_unix-seconds_nullable", + Name: "TestRequestStringTimeNullable", + ID: "test_request_string_time_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsNullableRequest(r, span) + request, close, err := s.decodeTestRequestStringTimeNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43616,15 +43040,15 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsNullable", - OperationID: "test_request_string_unix-seconds_nullable", + OperationName: "TestRequestStringTimeNullable", + OperationID: "test_request_string_time_nullable", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = OptNilStringUnixSeconds + Request = OptNilTime Params = struct{} Response = Error ) @@ -43637,11 +43061,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixSecondsNullable(ctx, request) + return s.h.TestRequestStringTimeNullable(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestStringTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -43649,23 +43073,23 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin return } - if err := encodeTestRequestStringUnixSecondsNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixSecondsNullableArrayRequest handles test_request_string_unix-seconds_nullable_array operation. +// HandleTestRequestStringTimeNullableArrayRequest handles test_request_string_time_nullable_array operation. // -// POST /test_request_string_unix-seconds_nullable_array -func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_nullable_array +func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_string_time_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43689,11 +43113,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsNullableArray", - ID: "test_request_string_unix-seconds_nullable_array", + Name: "TestRequestStringTimeNullableArray", + ID: "test_request_string_time_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringTimeNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43713,15 +43137,15 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsNullableArray", - OperationID: "test_request_string_unix-seconds_nullable_array", + OperationName: "TestRequestStringTimeNullableArray", + OperationID: "test_request_string_time_nullable_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = []NilStringUnixSeconds + Request = []NilTime Params = struct{} Response = Error ) @@ -43734,11 +43158,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) + return s.h.TestRequestStringTimeNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestStringTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43746,23 +43170,23 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] return } - if err := encodeTestRequestStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestRequestStringUnixSecondsNullableArrayArrayRequest handles test_request_string_unix-seconds_nullable_array_array operation. +// HandleTestRequestStringTimeNullableArrayArrayRequest handles test_request_string_time_nullable_array_array operation. // -// POST /test_request_string_unix-seconds_nullable_array_array -func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_nullable_array_array +func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_string_time_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43786,11 +43210,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsNullableArrayArray", - ID: "test_request_string_unix-seconds_nullable_array_array", + Name: "TestRequestStringTimeNullableArrayArray", + ID: "test_request_string_time_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestRequestStringTimeNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43810,15 +43234,15 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsNullableArrayArray", - OperationID: "test_request_string_unix-seconds_nullable_array_array", + OperationName: "TestRequestStringTimeNullableArrayArray", + OperationID: "test_request_string_time_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, } type ( - Request = [][]NilStringUnixSeconds + Request = [][]NilTime Params = struct{} Response = Error ) @@ -43831,11 +43255,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) + return s.h.TestRequestStringTimeNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43843,23 +43267,5843 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg return } - if err := encodeTestRequestStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseAnyRequest handles test_response_Any operation. +// HandleTestRequestStringURIRequest handles test_request_string_uri operation. // -// POST /test_response_Any -func (s *Server) handleTestResponseAnyRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uri +func (s *Server) handleTestRequestStringURIRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_Any"), + otelogen.OperationID("test_request_string_uri"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseAny", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURI", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringURI", + ID: "test_request_string_uri", + } + ) + request, close, err := s.decodeTestRequestStringURIRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringURI", + OperationID: "test_request_string_uri", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptURI + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringURI(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringURI(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringURIResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringURIArrayRequest handles test_request_string_uri_array operation. +// +// POST /test_request_string_uri_array +func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uri_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURIArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringURIArray", + ID: "test_request_string_uri_array", + } + ) + request, close, err := s.decodeTestRequestStringURIArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringURIArray", + OperationID: "test_request_string_uri_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []url.URL + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringURIArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringURIArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringURIArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringURIArrayArrayRequest handles test_request_string_uri_array_array operation. +// +// POST /test_request_string_uri_array_array +func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uri_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURIArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringURIArrayArray", + ID: "test_request_string_uri_array_array", + } + ) + request, close, err := s.decodeTestRequestStringURIArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringURIArrayArray", + OperationID: "test_request_string_uri_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]url.URL + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringURIArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringURIArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringURIArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringURINullableRequest handles test_request_string_uri_nullable operation. +// +// POST /test_request_string_uri_nullable +func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uri_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringURINullable", + ID: "test_request_string_uri_nullable", + } + ) + request, close, err := s.decodeTestRequestStringURINullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringURINullable", + OperationID: "test_request_string_uri_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptNilURI + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringURINullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringURINullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringURINullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringURINullableArrayRequest handles test_request_string_uri_nullable_array operation. +// +// POST /test_request_string_uri_nullable_array +func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uri_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringURINullableArray", + ID: "test_request_string_uri_nullable_array", + } + ) + request, close, err := s.decodeTestRequestStringURINullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringURINullableArray", + OperationID: "test_request_string_uri_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []NilURI + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringURINullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringURINullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringURINullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringURINullableArrayArrayRequest handles test_request_string_uri_nullable_array_array operation. +// +// POST /test_request_string_uri_nullable_array_array +func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uri_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringURINullableArrayArray", + ID: "test_request_string_uri_nullable_array_array", + } + ) + request, close, err := s.decodeTestRequestStringURINullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringURINullableArrayArray", + OperationID: "test_request_string_uri_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilURI + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringURINullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringURINullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringURINullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUUIDRequest handles test_request_string_uuid operation. +// +// POST /test_request_string_uuid +func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uuid"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUID", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUUID", + ID: "test_request_string_uuid", + } + ) + request, close, err := s.decodeTestRequestStringUUIDRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUUID", + OperationID: "test_request_string_uuid", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptUUID + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUUID(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUUID(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUUIDResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUUIDArrayRequest handles test_request_string_uuid_array operation. +// +// POST /test_request_string_uuid_array +func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uuid_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUUIDArray", + ID: "test_request_string_uuid_array", + } + ) + request, close, err := s.decodeTestRequestStringUUIDArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUUIDArray", + OperationID: "test_request_string_uuid_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []uuid.UUID + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUUIDArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUUIDArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUUIDArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUUIDArrayArrayRequest handles test_request_string_uuid_array_array operation. +// +// POST /test_request_string_uuid_array_array +func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uuid_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUUIDArrayArray", + ID: "test_request_string_uuid_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUUIDArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUUIDArrayArray", + OperationID: "test_request_string_uuid_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]uuid.UUID + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUUIDArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUUIDArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUUIDArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUUIDNullableRequest handles test_request_string_uuid_nullable operation. +// +// POST /test_request_string_uuid_nullable +func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uuid_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUUIDNullable", + ID: "test_request_string_uuid_nullable", + } + ) + request, close, err := s.decodeTestRequestStringUUIDNullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUUIDNullable", + OperationID: "test_request_string_uuid_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptNilUUID + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUUIDNullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUUIDNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUUIDNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUUIDNullableArrayRequest handles test_request_string_uuid_nullable_array operation. +// +// POST /test_request_string_uuid_nullable_array +func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uuid_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUUIDNullableArray", + ID: "test_request_string_uuid_nullable_array", + } + ) + request, close, err := s.decodeTestRequestStringUUIDNullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUUIDNullableArray", + OperationID: "test_request_string_uuid_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []NilUUID + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUUIDNullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUUIDNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUUIDNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUUIDNullableArrayArrayRequest handles test_request_string_uuid_nullable_array_array operation. +// +// POST /test_request_string_uuid_nullable_array_array +func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_uuid_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUUIDNullableArrayArray", + ID: "test_request_string_uuid_nullable_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUUIDNullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUUIDNullableArrayArray", + OperationID: "test_request_string_uuid_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilUUID + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixRequest handles test_request_string_unix operation. +// +// POST /test_request_string_unix +func (s *Server) handleTestRequestStringUnixRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnix", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnix", + ID: "test_request_string_unix", + } + ) + request, close, err := s.decodeTestRequestStringUnixRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnix", + OperationID: "test_request_string_unix", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnix(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnix(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixArrayRequest handles test_request_string_unix_array operation. +// +// POST /test_request_string_unix_array +func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixArray", + ID: "test_request_string_unix_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixArray", + OperationID: "test_request_string_unix_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixArrayArrayRequest handles test_request_string_unix_array_array operation. +// +// POST /test_request_string_unix_array_array +func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixArrayArray", + ID: "test_request_string_unix_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixArrayArray", + OperationID: "test_request_string_unix_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMicroRequest handles test_request_string_unix-micro operation. +// +// POST /test_request_string_unix-micro +func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-micro"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicro", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMicro", + ID: "test_request_string_unix-micro", + } + ) + request, close, err := s.decodeTestRequestStringUnixMicroRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMicro", + OperationID: "test_request_string_unix-micro", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptStringUnixMicro + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMicro(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMicro(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMicroResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMicroArrayRequest handles test_request_string_unix-micro_array operation. +// +// POST /test_request_string_unix-micro_array +func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-micro_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMicroArray", + ID: "test_request_string_unix-micro_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMicroArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMicroArray", + OperationID: "test_request_string_unix-micro_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMicroArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMicroArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMicroArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMicroArrayArrayRequest handles test_request_string_unix-micro_array_array operation. +// +// POST /test_request_string_unix-micro_array_array +func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-micro_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMicroArrayArray", + ID: "test_request_string_unix-micro_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMicroArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMicroArrayArray", + OperationID: "test_request_string_unix-micro_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMicroArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMicroArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMicroArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMicroNullableRequest handles test_request_string_unix-micro_nullable operation. +// +// POST /test_request_string_unix-micro_nullable +func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-micro_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMicroNullable", + ID: "test_request_string_unix-micro_nullable", + } + ) + request, close, err := s.decodeTestRequestStringUnixMicroNullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMicroNullable", + OperationID: "test_request_string_unix-micro_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptNilStringUnixMicro + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMicroNullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMicroNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMicroNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMicroNullableArrayRequest handles test_request_string_unix-micro_nullable_array operation. +// +// POST /test_request_string_unix-micro_nullable_array +func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-micro_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMicroNullableArray", + ID: "test_request_string_unix-micro_nullable_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMicroNullableArray", + OperationID: "test_request_string_unix-micro_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []NilStringUnixMicro + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMicroNullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMicroNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMicroNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMicroNullableArrayArrayRequest handles test_request_string_unix-micro_nullable_array_array operation. +// +// POST /test_request_string_unix-micro_nullable_array_array +func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-micro_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMicroNullableArrayArray", + ID: "test_request_string_unix-micro_nullable_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMicroNullableArrayArray", + OperationID: "test_request_string_unix-micro_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilStringUnixMicro + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMilliRequest handles test_request_string_unix-milli operation. +// +// POST /test_request_string_unix-milli +func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-milli"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilli", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMilli", + ID: "test_request_string_unix-milli", + } + ) + request, close, err := s.decodeTestRequestStringUnixMilliRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMilli", + OperationID: "test_request_string_unix-milli", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptStringUnixMilli + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMilli(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMilli(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMilliResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMilliArrayRequest handles test_request_string_unix-milli_array operation. +// +// POST /test_request_string_unix-milli_array +func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-milli_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMilliArray", + ID: "test_request_string_unix-milli_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMilliArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMilliArray", + OperationID: "test_request_string_unix-milli_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMilliArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMilliArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMilliArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMilliArrayArrayRequest handles test_request_string_unix-milli_array_array operation. +// +// POST /test_request_string_unix-milli_array_array +func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-milli_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMilliArrayArray", + ID: "test_request_string_unix-milli_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMilliArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMilliArrayArray", + OperationID: "test_request_string_unix-milli_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMilliArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMilliArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMilliArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMilliNullableRequest handles test_request_string_unix-milli_nullable operation. +// +// POST /test_request_string_unix-milli_nullable +func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-milli_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMilliNullable", + ID: "test_request_string_unix-milli_nullable", + } + ) + request, close, err := s.decodeTestRequestStringUnixMilliNullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMilliNullable", + OperationID: "test_request_string_unix-milli_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptNilStringUnixMilli + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMilliNullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMilliNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMilliNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMilliNullableArrayRequest handles test_request_string_unix-milli_nullable_array operation. +// +// POST /test_request_string_unix-milli_nullable_array +func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-milli_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMilliNullableArray", + ID: "test_request_string_unix-milli_nullable_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMilliNullableArray", + OperationID: "test_request_string_unix-milli_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []NilStringUnixMilli + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMilliNullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMilliNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMilliNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixMilliNullableArrayArrayRequest handles test_request_string_unix-milli_nullable_array_array operation. +// +// POST /test_request_string_unix-milli_nullable_array_array +func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-milli_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixMilliNullableArrayArray", + ID: "test_request_string_unix-milli_nullable_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixMilliNullableArrayArray", + OperationID: "test_request_string_unix-milli_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilStringUnixMilli + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNanoRequest handles test_request_string_unix-nano operation. +// +// POST /test_request_string_unix-nano +func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-nano"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNano", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNano", + ID: "test_request_string_unix-nano", + } + ) + request, close, err := s.decodeTestRequestStringUnixNanoRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNano", + OperationID: "test_request_string_unix-nano", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptStringUnixNano + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNano(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNano(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNanoResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNanoArrayRequest handles test_request_string_unix-nano_array operation. +// +// POST /test_request_string_unix-nano_array +func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-nano_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNanoArray", + ID: "test_request_string_unix-nano_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixNanoArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNanoArray", + OperationID: "test_request_string_unix-nano_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNanoArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNanoArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNanoArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNanoArrayArrayRequest handles test_request_string_unix-nano_array_array operation. +// +// POST /test_request_string_unix-nano_array_array +func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-nano_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNanoArrayArray", + ID: "test_request_string_unix-nano_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixNanoArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNanoArrayArray", + OperationID: "test_request_string_unix-nano_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNanoArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNanoArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNanoArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNanoNullableRequest handles test_request_string_unix-nano_nullable operation. +// +// POST /test_request_string_unix-nano_nullable +func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-nano_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNanoNullable", + ID: "test_request_string_unix-nano_nullable", + } + ) + request, close, err := s.decodeTestRequestStringUnixNanoNullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNanoNullable", + OperationID: "test_request_string_unix-nano_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptNilStringUnixNano + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNanoNullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNanoNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNanoNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNanoNullableArrayRequest handles test_request_string_unix-nano_nullable_array operation. +// +// POST /test_request_string_unix-nano_nullable_array +func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-nano_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNanoNullableArray", + ID: "test_request_string_unix-nano_nullable_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNanoNullableArray", + OperationID: "test_request_string_unix-nano_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []NilStringUnixNano + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNanoNullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNanoNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNanoNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNanoNullableArrayArrayRequest handles test_request_string_unix-nano_nullable_array_array operation. +// +// POST /test_request_string_unix-nano_nullable_array_array +func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-nano_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNanoNullableArrayArray", + ID: "test_request_string_unix-nano_nullable_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNanoNullableArrayArray", + OperationID: "test_request_string_unix-nano_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilStringUnixNano + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNullableRequest handles test_request_string_unix_nullable operation. +// +// POST /test_request_string_unix_nullable +func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNullable", + ID: "test_request_string_unix_nullable", + } + ) + request, close, err := s.decodeTestRequestStringUnixNullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNullable", + OperationID: "test_request_string_unix_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptNilStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNullableArrayRequest handles test_request_string_unix_nullable_array operation. +// +// POST /test_request_string_unix_nullable_array +func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNullableArray", + ID: "test_request_string_unix_nullable_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixNullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNullableArray", + OperationID: "test_request_string_unix_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []NilStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixNullableArrayArrayRequest handles test_request_string_unix_nullable_array_array operation. +// +// POST /test_request_string_unix_nullable_array_array +func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixNullableArrayArray", + ID: "test_request_string_unix_nullable_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixNullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixNullableArrayArray", + OperationID: "test_request_string_unix_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixSecondsRequest handles test_request_string_unix-seconds operation. +// +// POST /test_request_string_unix-seconds +func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-seconds"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSeconds", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixSeconds", + ID: "test_request_string_unix-seconds", + } + ) + request, close, err := s.decodeTestRequestStringUnixSecondsRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixSeconds", + OperationID: "test_request_string_unix-seconds", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixSeconds(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixSeconds(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixSecondsResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixSecondsArrayRequest handles test_request_string_unix-seconds_array operation. +// +// POST /test_request_string_unix-seconds_array +func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-seconds_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixSecondsArray", + ID: "test_request_string_unix-seconds_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixSecondsArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixSecondsArray", + OperationID: "test_request_string_unix-seconds_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixSecondsArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixSecondsArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixSecondsArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixSecondsArrayArrayRequest handles test_request_string_unix-seconds_array_array operation. +// +// POST /test_request_string_unix-seconds_array_array +func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-seconds_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixSecondsArrayArray", + ID: "test_request_string_unix-seconds_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixSecondsArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixSecondsArrayArray", + OperationID: "test_request_string_unix-seconds_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]time.Time + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixSecondsNullableRequest handles test_request_string_unix-seconds_nullable operation. +// +// POST /test_request_string_unix-seconds_nullable +func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-seconds_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixSecondsNullable", + ID: "test_request_string_unix-seconds_nullable", + } + ) + request, close, err := s.decodeTestRequestStringUnixSecondsNullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixSecondsNullable", + OperationID: "test_request_string_unix-seconds_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = OptNilStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixSecondsNullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixSecondsNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixSecondsNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixSecondsNullableArrayRequest handles test_request_string_unix-seconds_nullable_array operation. +// +// POST /test_request_string_unix-seconds_nullable_array +func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-seconds_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixSecondsNullableArray", + ID: "test_request_string_unix-seconds_nullable_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixSecondsNullableArray", + OperationID: "test_request_string_unix-seconds_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = []NilStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestRequestStringUnixSecondsNullableArrayArrayRequest handles test_request_string_unix-seconds_nullable_array_array operation. +// +// POST /test_request_string_unix-seconds_nullable_array_array +func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_unix-seconds_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestRequestStringUnixSecondsNullableArrayArray", + ID: "test_request_string_unix-seconds_nullable_array_array", + } + ) + request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response Error + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestRequestStringUnixSecondsNullableArrayArray", + OperationID: "test_request_string_unix-seconds_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = [][]NilStringUnixSeconds + Params = struct{} + Response = Error + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestRequestStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseAnyRequest handles test_response_Any operation. +// +// POST /test_response_Any +func (s *Server) handleTestResponseAnyRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_Any"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseAny", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseAny", + ID: "test_response_Any", + } + ) + request, close, err := s.decodeTestResponseAnyRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response jx.Raw + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseAny", + OperationID: "test_response_Any", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = jx.Raw + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseAny(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseAny(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseAnyResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseBooleanRequest handles test_response_boolean operation. +// +// POST /test_response_boolean +func (s *Server) handleTestResponseBooleanRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_boolean"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBoolean", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseBoolean", + ID: "test_response_boolean", + } + ) + request, close, err := s.decodeTestResponseBooleanRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response bool + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseBoolean", + OperationID: "test_response_boolean", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = bool + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseBoolean(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseBoolean(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseBooleanResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseBooleanArrayRequest handles test_response_boolean_array operation. +// +// POST /test_response_boolean_array +func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_boolean_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseBooleanArray", + ID: "test_response_boolean_array", + } + ) + request, close, err := s.decodeTestResponseBooleanArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response []bool + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseBooleanArray", + OperationID: "test_response_boolean_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []bool + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseBooleanArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseBooleanArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseBooleanArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseBooleanArrayArrayRequest handles test_response_boolean_array_array operation. +// +// POST /test_response_boolean_array_array +func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_boolean_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseBooleanArrayArray", + ID: "test_response_boolean_array_array", + } + ) + request, close, err := s.decodeTestResponseBooleanArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response [][]bool + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseBooleanArrayArray", + OperationID: "test_response_boolean_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]bool + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseBooleanArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseBooleanArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseBooleanArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseBooleanNullableRequest handles test_response_boolean_nullable operation. +// +// POST /test_response_boolean_nullable +func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_boolean_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseBooleanNullable", + ID: "test_response_boolean_nullable", + } + ) + request, close, err := s.decodeTestResponseBooleanNullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response NilBool + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseBooleanNullable", + OperationID: "test_response_boolean_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = NilBool + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseBooleanNullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseBooleanNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseBooleanNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseBooleanNullableArrayRequest handles test_response_boolean_nullable_array operation. +// +// POST /test_response_boolean_nullable_array +func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_boolean_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseBooleanNullableArray", + ID: "test_response_boolean_nullable_array", + } + ) + request, close, err := s.decodeTestResponseBooleanNullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response []NilBool + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseBooleanNullableArray", + OperationID: "test_response_boolean_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []NilBool + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseBooleanNullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseBooleanNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseBooleanNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseBooleanNullableArrayArrayRequest handles test_response_boolean_nullable_array_array operation. +// +// POST /test_response_boolean_nullable_array_array +func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_boolean_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseBooleanNullableArrayArray", + ID: "test_response_boolean_nullable_array_array", + } + ) + request, close, err := s.decodeTestResponseBooleanNullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response [][]NilBool + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseBooleanNullableArrayArray", + OperationID: "test_response_boolean_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]NilBool + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseBooleanNullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseBooleanNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseBooleanNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseEmptyStructRequest handles test_response_EmptyStruct operation. +// +// POST /test_response_EmptyStruct +func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_EmptyStruct"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseEmptyStruct", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseEmptyStruct", + ID: "test_response_EmptyStruct", + } + ) + request, close, err := s.decodeTestResponseEmptyStructRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response TestResponseEmptyStructOK + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseEmptyStruct", + OperationID: "test_response_EmptyStruct", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = TestResponseEmptyStructOK + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseEmptyStruct(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseEmptyStruct(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseEmptyStructResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseFormatTestRequest handles test_response_FormatTest operation. +// +// POST /test_response_FormatTest +func (s *Server) handleTestResponseFormatTestRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_FormatTest"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseFormatTest", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseFormatTest", + ID: "test_response_FormatTest", + } + ) + request, close, err := s.decodeTestResponseFormatTestRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response TestResponseFormatTestOK + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseFormatTest", + OperationID: "test_response_FormatTest", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = TestResponseFormatTestOK + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseFormatTest(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseFormatTest(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseFormatTestResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerRequest handles test_response_integer operation. +// +// POST /test_response_integer +func (s *Server) handleTestResponseIntegerRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseInteger", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseInteger", + ID: "test_response_integer", + } + ) + request, close, err := s.decodeTestResponseIntegerRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response int + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseInteger", + OperationID: "test_response_integer", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = int + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseInteger(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseInteger(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerArrayRequest handles test_response_integer_array operation. +// +// POST /test_response_integer_array +func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerArray", + ID: "test_response_integer_array", + } + ) + request, close, err := s.decodeTestResponseIntegerArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response []int + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerArray", + OperationID: "test_response_integer_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []int + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerArrayArrayRequest handles test_response_integer_array_array operation. +// +// POST /test_response_integer_array_array +func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerArrayArray", + ID: "test_response_integer_array_array", + } + ) + request, close, err := s.decodeTestResponseIntegerArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response [][]int + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerArrayArray", + OperationID: "test_response_integer_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]int + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerInt32Request handles test_response_integer_int32 operation. +// +// POST /test_response_integer_int32 +func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_int32"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerInt32", + ID: "test_response_integer_int32", + } + ) + request, close, err := s.decodeTestResponseIntegerInt32Request(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response int32 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerInt32", + OperationID: "test_response_integer_int32", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = int32 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerInt32(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerInt32(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerInt32Response(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerInt32ArrayRequest handles test_response_integer_int32_array operation. +// +// POST /test_response_integer_int32_array +func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_int32_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Array", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerInt32Array", + ID: "test_response_integer_int32_array", + } + ) + request, close, err := s.decodeTestResponseIntegerInt32ArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response []int32 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerInt32Array", + OperationID: "test_response_integer_int32_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []int32 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerInt32Array(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerInt32Array(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerInt32ArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerInt32ArrayArrayRequest handles test_response_integer_int32_array_array operation. +// +// POST /test_response_integer_int32_array_array +func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_int32_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32ArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerInt32ArrayArray", + ID: "test_response_integer_int32_array_array", + } + ) + request, close, err := s.decodeTestResponseIntegerInt32ArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response [][]int32 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerInt32ArrayArray", + OperationID: "test_response_integer_int32_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]int32 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerInt32ArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerInt32ArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerInt32ArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerInt32NullableRequest handles test_response_integer_int32_nullable operation. +// +// POST /test_response_integer_int32_nullable +func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_int32_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Nullable", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerInt32Nullable", + ID: "test_response_integer_int32_nullable", + } + ) + request, close, err := s.decodeTestResponseIntegerInt32NullableRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response NilInt32 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerInt32Nullable", + OperationID: "test_response_integer_int32_nullable", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = NilInt32 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerInt32Nullable(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerInt32Nullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerInt32NullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerInt32NullableArrayRequest handles test_response_integer_int32_nullable_array operation. +// +// POST /test_response_integer_int32_nullable_array +func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_int32_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerInt32NullableArray", + ID: "test_response_integer_int32_nullable_array", + } + ) + request, close, err := s.decodeTestResponseIntegerInt32NullableArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response []NilInt32 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerInt32NullableArray", + OperationID: "test_response_integer_int32_nullable_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []NilInt32 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerInt32NullableArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerInt32NullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerInt32NullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerInt32NullableArrayArrayRequest handles test_response_integer_int32_nullable_array_array operation. +// +// POST /test_response_integer_int32_nullable_array_array +func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_int32_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArrayArray", + trace.WithAttributes(otelAttrs...), + trace.WithSpanKind(trace.SpanKindServer), + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, otelAttrs...) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, otelAttrs...) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseIntegerInt32NullableArrayArray", + ID: "test_response_integer_int32_nullable_array_array", + } + ) + request, close, err := s.decodeTestResponseIntegerInt32NullableArrayArrayRequest(r, span) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response [][]NilInt32 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseIntegerInt32NullableArrayArray", + OperationID: "test_response_integer_int32_nullable_array_array", + Body: request, + Params: map[string]any{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]NilInt32 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (Response, error) { + return s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) + }, + ) + } else { + response, err = s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseIntegerInt32NullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } +} + +// HandleTestResponseIntegerInt64Request handles test_response_integer_int64 operation. +// +// POST /test_response_integer_int64 +func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_integer_int64"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43883,11 +49127,11 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, w http.ResponseWri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseAny", - ID: "test_response_Any", + Name: "TestResponseIntegerInt64", + ID: "test_response_integer_int64", } ) - request, close, err := s.decodeTestResponseAnyRequest(r, span) + request, close, err := s.decodeTestResponseIntegerInt64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43903,12 +49147,12 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, w http.ResponseWri } }() - var response jx.Raw + var response int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseAny", - OperationID: "test_response_Any", + OperationName: "TestResponseIntegerInt64", + OperationID: "test_response_integer_int64", Body: request, Params: map[string]any{}, Raw: r, @@ -43917,7 +49161,7 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, w http.ResponseWri type ( Request = string Params = struct{} - Response = jx.Raw + Response = int64 ) response, err = middleware.HookMiddleware[ Request, @@ -43928,11 +49172,11 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, w http.ResponseWri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseAny(ctx, request) + return s.h.TestResponseIntegerInt64(ctx, request) }, ) } else { - response, err = s.h.TestResponseAny(ctx, request) + response, err = s.h.TestResponseIntegerInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -43940,23 +49184,23 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, w http.ResponseWri return } - if err := encodeTestResponseAnyResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseBooleanRequest handles test_response_boolean operation. +// HandleTestResponseIntegerInt64ArrayRequest handles test_response_integer_int64_array operation. // -// POST /test_response_boolean -func (s *Server) handleTestResponseBooleanRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_array +func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean"), + otelogen.OperationID("test_response_integer_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBoolean", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -43980,11 +49224,11 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, w http.Respons } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBoolean", - ID: "test_response_boolean", + Name: "TestResponseIntegerInt64Array", + ID: "test_response_integer_int64_array", } ) - request, close, err := s.decodeTestResponseBooleanRequest(r, span) + request, close, err := s.decodeTestResponseIntegerInt64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44000,12 +49244,12 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, w http.Respons } }() - var response bool + var response []int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBoolean", - OperationID: "test_response_boolean", + OperationName: "TestResponseIntegerInt64Array", + OperationID: "test_response_integer_int64_array", Body: request, Params: map[string]any{}, Raw: r, @@ -44014,7 +49258,7 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, w http.Respons type ( Request = string Params = struct{} - Response = bool + Response = []int64 ) response, err = middleware.HookMiddleware[ Request, @@ -44025,11 +49269,11 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, w http.Respons mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseBoolean(ctx, request) + return s.h.TestResponseIntegerInt64Array(ctx, request) }, ) } else { - response, err = s.h.TestResponseBoolean(ctx, request) + response, err = s.h.TestResponseIntegerInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -44037,23 +49281,23 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, w http.Respons return } - if err := encodeTestResponseBooleanResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseBooleanArrayRequest handles test_response_boolean_array operation. +// HandleTestResponseIntegerInt64ArrayArrayRequest handles test_response_integer_int64_array_array operation. // -// POST /test_response_boolean_array -func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_array_array +func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_array"), + otelogen.OperationID("test_response_integer_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44077,11 +49321,11 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, w http.Re } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanArray", - ID: "test_response_boolean_array", + Name: "TestResponseIntegerInt64ArrayArray", + ID: "test_response_integer_int64_array_array", } ) - request, close, err := s.decodeTestResponseBooleanArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerInt64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44097,12 +49341,12 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, w http.Re } }() - var response []bool + var response [][]int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanArray", - OperationID: "test_response_boolean_array", + OperationName: "TestResponseIntegerInt64ArrayArray", + OperationID: "test_response_integer_int64_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -44111,7 +49355,7 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, w http.Re type ( Request = string Params = struct{} - Response = []bool + Response = [][]int64 ) response, err = middleware.HookMiddleware[ Request, @@ -44122,11 +49366,11 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, w http.Re mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseBooleanArray(ctx, request) + return s.h.TestResponseIntegerInt64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseBooleanArray(ctx, request) + response, err = s.h.TestResponseIntegerInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44134,23 +49378,23 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, w http.Re return } - if err := encodeTestResponseBooleanArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseBooleanArrayArrayRequest handles test_response_boolean_array_array operation. +// HandleTestResponseIntegerInt64NullableRequest handles test_response_integer_int64_nullable operation. // -// POST /test_response_boolean_array_array -func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_nullable +func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_array_array"), + otelogen.OperationID("test_response_integer_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44174,11 +49418,11 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanArrayArray", - ID: "test_response_boolean_array_array", + Name: "TestResponseIntegerInt64Nullable", + ID: "test_response_integer_int64_nullable", } ) - request, close, err := s.decodeTestResponseBooleanArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerInt64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44194,12 +49438,12 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, w ht } }() - var response [][]bool + var response NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanArrayArray", - OperationID: "test_response_boolean_array_array", + OperationName: "TestResponseIntegerInt64Nullable", + OperationID: "test_response_integer_int64_nullable", Body: request, Params: map[string]any{}, Raw: r, @@ -44208,7 +49452,7 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, w ht type ( Request = string Params = struct{} - Response = [][]bool + Response = NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -44219,11 +49463,11 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseBooleanArrayArray(ctx, request) + return s.h.TestResponseIntegerInt64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestResponseBooleanArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -44231,23 +49475,23 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, w ht return } - if err := encodeTestResponseBooleanArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseBooleanNullableRequest handles test_response_boolean_nullable operation. +// HandleTestResponseIntegerInt64NullableArrayRequest handles test_response_integer_int64_nullable_array operation. // -// POST /test_response_boolean_nullable -func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_nullable_array +func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable"), + otelogen.OperationID("test_response_integer_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44271,11 +49515,11 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanNullable", - ID: "test_response_boolean_nullable", + Name: "TestResponseIntegerInt64NullableArray", + ID: "test_response_integer_int64_nullable_array", } ) - request, close, err := s.decodeTestResponseBooleanNullableRequest(r, span) + request, close, err := s.decodeTestResponseIntegerInt64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44291,12 +49535,12 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, w http } }() - var response NilBool + var response []NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanNullable", - OperationID: "test_response_boolean_nullable", + OperationName: "TestResponseIntegerInt64NullableArray", + OperationID: "test_response_integer_int64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -44305,7 +49549,7 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, w http type ( Request = string Params = struct{} - Response = NilBool + Response = []NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -44316,11 +49560,11 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseBooleanNullable(ctx, request) + return s.h.TestResponseIntegerInt64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseBooleanNullable(ctx, request) + response, err = s.h.TestResponseIntegerInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44328,23 +49572,23 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, w http return } - if err := encodeTestResponseBooleanNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseBooleanNullableArrayRequest handles test_response_boolean_nullable_array operation. +// HandleTestResponseIntegerInt64NullableArrayArrayRequest handles test_response_integer_int64_nullable_array_array operation. // -// POST /test_response_boolean_nullable_array -func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_nullable_array_array +func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable_array"), + otelogen.OperationID("test_response_integer_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44368,11 +49612,11 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanNullableArray", - ID: "test_response_boolean_nullable_array", + Name: "TestResponseIntegerInt64NullableArrayArray", + ID: "test_response_integer_int64_nullable_array_array", } ) - request, close, err := s.decodeTestResponseBooleanNullableArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerInt64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44388,12 +49632,12 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, w } }() - var response []NilBool + var response [][]NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanNullableArray", - OperationID: "test_response_boolean_nullable_array", + OperationName: "TestResponseIntegerInt64NullableArrayArray", + OperationID: "test_response_integer_int64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -44402,7 +49646,7 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, w type ( Request = string Params = struct{} - Response = []NilBool + Response = [][]NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -44413,11 +49657,11 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseBooleanNullableArray(ctx, request) + return s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseBooleanNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44425,23 +49669,23 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, w return } - if err := encodeTestResponseBooleanNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseBooleanNullableArrayArrayRequest handles test_response_boolean_nullable_array_array operation. +// HandleTestResponseIntegerNullableRequest handles test_response_integer_nullable operation. // -// POST /test_response_boolean_nullable_array_array -func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_nullable +func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable_array_array"), + otelogen.OperationID("test_response_integer_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44465,11 +49709,11 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanNullableArrayArray", - ID: "test_response_boolean_nullable_array_array", + Name: "TestResponseIntegerNullable", + ID: "test_response_integer_nullable", } ) - request, close, err := s.decodeTestResponseBooleanNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44485,12 +49729,12 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri } }() - var response [][]NilBool + var response NilInt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanNullableArrayArray", - OperationID: "test_response_boolean_nullable_array_array", + OperationName: "TestResponseIntegerNullable", + OperationID: "test_response_integer_nullable", Body: request, Params: map[string]any{}, Raw: r, @@ -44499,7 +49743,7 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = [][]NilBool + Response = NilInt ) response, err = middleware.HookMiddleware[ Request, @@ -44510,11 +49754,11 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseBooleanNullableArrayArray(ctx, request) + return s.h.TestResponseIntegerNullable(ctx, request) }, ) } else { - response, err = s.h.TestResponseBooleanNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -44522,23 +49766,23 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri return } - if err := encodeTestResponseBooleanNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseEmptyStructRequest handles test_response_EmptyStruct operation. +// HandleTestResponseIntegerNullableArrayRequest handles test_response_integer_nullable_array operation. // -// POST /test_response_EmptyStruct -func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_nullable_array +func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_EmptyStruct"), + otelogen.OperationID("test_response_integer_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseEmptyStruct", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44562,11 +49806,11 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, w http.Res } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseEmptyStruct", - ID: "test_response_EmptyStruct", + Name: "TestResponseIntegerNullableArray", + ID: "test_response_integer_nullable_array", } ) - request, close, err := s.decodeTestResponseEmptyStructRequest(r, span) + request, close, err := s.decodeTestResponseIntegerNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44582,12 +49826,12 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, w http.Res } }() - var response TestResponseEmptyStructOK + var response []NilInt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseEmptyStruct", - OperationID: "test_response_EmptyStruct", + OperationName: "TestResponseIntegerNullableArray", + OperationID: "test_response_integer_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -44596,7 +49840,7 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, w http.Res type ( Request = string Params = struct{} - Response = TestResponseEmptyStructOK + Response = []NilInt ) response, err = middleware.HookMiddleware[ Request, @@ -44607,11 +49851,11 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, w http.Res mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseEmptyStruct(ctx, request) + return s.h.TestResponseIntegerNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseEmptyStruct(ctx, request) + response, err = s.h.TestResponseIntegerNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44619,23 +49863,23 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, w http.Res return } - if err := encodeTestResponseEmptyStructResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseFormatTestRequest handles test_response_FormatTest operation. +// HandleTestResponseIntegerNullableArrayArrayRequest handles test_response_integer_nullable_array_array operation. // -// POST /test_response_FormatTest -func (s *Server) handleTestResponseFormatTestRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_nullable_array_array +func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_FormatTest"), + otelogen.OperationID("test_response_integer_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseFormatTest", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44659,11 +49903,11 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, w http.Resp } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseFormatTest", - ID: "test_response_FormatTest", + Name: "TestResponseIntegerNullableArrayArray", + ID: "test_response_integer_nullable_array_array", } ) - request, close, err := s.decodeTestResponseFormatTestRequest(r, span) + request, close, err := s.decodeTestResponseIntegerNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44679,12 +49923,12 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, w http.Resp } }() - var response TestResponseFormatTestOK + var response [][]NilInt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseFormatTest", - OperationID: "test_response_FormatTest", + OperationName: "TestResponseIntegerNullableArrayArray", + OperationID: "test_response_integer_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -44693,7 +49937,7 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, w http.Resp type ( Request = string Params = struct{} - Response = TestResponseFormatTestOK + Response = [][]NilInt ) response, err = middleware.HookMiddleware[ Request, @@ -44704,11 +49948,11 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, w http.Resp mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseFormatTest(ctx, request) + return s.h.TestResponseIntegerNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseFormatTest(ctx, request) + response, err = s.h.TestResponseIntegerNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44716,23 +49960,23 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, w http.Resp return } - if err := encodeTestResponseFormatTestResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerRequest handles test_response_integer operation. +// HandleTestResponseIntegerUintRequest handles test_response_integer_uint operation. // -// POST /test_response_integer -func (s *Server) handleTestResponseIntegerRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint +func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer"), + otelogen.OperationID("test_response_integer_uint"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseInteger", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44756,11 +50000,11 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, w http.Respons } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseInteger", - ID: "test_response_integer", + Name: "TestResponseIntegerUint", + ID: "test_response_integer_uint", } ) - request, close, err := s.decodeTestResponseIntegerRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUintRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44776,12 +50020,12 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, w http.Respons } }() - var response int + var response uint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseInteger", - OperationID: "test_response_integer", + OperationName: "TestResponseIntegerUint", + OperationID: "test_response_integer_uint", Body: request, Params: map[string]any{}, Raw: r, @@ -44790,7 +50034,7 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, w http.Respons type ( Request = string Params = struct{} - Response = int + Response = uint ) response, err = middleware.HookMiddleware[ Request, @@ -44801,11 +50045,11 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, w http.Respons mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseInteger(ctx, request) + return s.h.TestResponseIntegerUint(ctx, request) }, ) } else { - response, err = s.h.TestResponseInteger(ctx, request) + response, err = s.h.TestResponseIntegerUint(ctx, request) } if err != nil { recordError("Internal", err) @@ -44813,23 +50057,23 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, w http.Respons return } - if err := encodeTestResponseIntegerResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerArrayRequest handles test_response_integer_array operation. +// HandleTestResponseIntegerUint32Request handles test_response_integer_uint32 operation. // -// POST /test_response_integer_array -func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32 +func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_array"), + otelogen.OperationID("test_response_integer_uint32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44853,11 +50097,11 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, w http.Re } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerArray", - ID: "test_response_integer_array", + Name: "TestResponseIntegerUint32", + ID: "test_response_integer_uint32", } ) - request, close, err := s.decodeTestResponseIntegerArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint32Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44873,12 +50117,12 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, w http.Re } }() - var response []int + var response uint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerArray", - OperationID: "test_response_integer_array", + OperationName: "TestResponseIntegerUint32", + OperationID: "test_response_integer_uint32", Body: request, Params: map[string]any{}, Raw: r, @@ -44887,7 +50131,7 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, w http.Re type ( Request = string Params = struct{} - Response = []int + Response = uint32 ) response, err = middleware.HookMiddleware[ Request, @@ -44898,11 +50142,11 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, w http.Re mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerArray(ctx, request) + return s.h.TestResponseIntegerUint32(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32(ctx, request) } if err != nil { recordError("Internal", err) @@ -44910,23 +50154,23 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, w http.Re return } - if err := encodeTestResponseIntegerArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerArrayArrayRequest handles test_response_integer_array_array operation. +// HandleTestResponseIntegerUint32ArrayRequest handles test_response_integer_uint32_array operation. // -// POST /test_response_integer_array_array -func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_array +func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_array_array"), + otelogen.OperationID("test_response_integer_uint32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -44950,11 +50194,11 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerArrayArray", - ID: "test_response_integer_array_array", + Name: "TestResponseIntegerUint32Array", + ID: "test_response_integer_uint32_array", } ) - request, close, err := s.decodeTestResponseIntegerArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint32ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44970,12 +50214,12 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, w ht } }() - var response [][]int + var response []uint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerArrayArray", - OperationID: "test_response_integer_array_array", + OperationName: "TestResponseIntegerUint32Array", + OperationID: "test_response_integer_uint32_array", Body: request, Params: map[string]any{}, Raw: r, @@ -44984,7 +50228,7 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, w ht type ( Request = string Params = struct{} - Response = [][]int + Response = []uint32 ) response, err = middleware.HookMiddleware[ Request, @@ -44995,11 +50239,11 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerArrayArray(ctx, request) + return s.h.TestResponseIntegerUint32Array(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -45007,23 +50251,23 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, w ht return } - if err := encodeTestResponseIntegerArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt32Request handles test_response_integer_int32 operation. +// HandleTestResponseIntegerUint32ArrayArrayRequest handles test_response_integer_uint32_array_array operation. // -// POST /test_response_integer_int32 -func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_array_array +func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32"), + otelogen.OperationID("test_response_integer_uint32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45047,11 +50291,11 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, w http.Re } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32", - ID: "test_response_integer_int32", + Name: "TestResponseIntegerUint32ArrayArray", + ID: "test_response_integer_uint32_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt32Request(r, span) + request, close, err := s.decodeTestResponseIntegerUint32ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45067,12 +50311,12 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, w http.Re } }() - var response int32 + var response [][]uint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32", - OperationID: "test_response_integer_int32", + OperationName: "TestResponseIntegerUint32ArrayArray", + OperationID: "test_response_integer_uint32_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -45081,7 +50325,7 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, w http.Re type ( Request = string Params = struct{} - Response = int32 + Response = [][]uint32 ) response, err = middleware.HookMiddleware[ Request, @@ -45092,11 +50336,11 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, w http.Re mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt32(ctx, request) + return s.h.TestResponseIntegerUint32ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt32(ctx, request) + response, err = s.h.TestResponseIntegerUint32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45104,23 +50348,23 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, w http.Re return } - if err := encodeTestResponseIntegerInt32Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt32ArrayRequest handles test_response_integer_int32_array operation. +// HandleTestResponseIntegerUint32NullableRequest handles test_response_integer_uint32_nullable operation. // -// POST /test_response_integer_int32_array -func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_nullable +func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_array"), + otelogen.OperationID("test_response_integer_uint32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45144,11 +50388,11 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32Array", - ID: "test_response_integer_int32_array", + Name: "TestResponseIntegerUint32Nullable", + ID: "test_response_integer_uint32_nullable", } ) - request, close, err := s.decodeTestResponseIntegerInt32ArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint32NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45164,12 +50408,12 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, w ht } }() - var response []int32 + var response NilUint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32Array", - OperationID: "test_response_integer_int32_array", + OperationName: "TestResponseIntegerUint32Nullable", + OperationID: "test_response_integer_uint32_nullable", Body: request, Params: map[string]any{}, Raw: r, @@ -45178,7 +50422,7 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, w ht type ( Request = string Params = struct{} - Response = []int32 + Response = NilUint32 ) response, err = middleware.HookMiddleware[ Request, @@ -45189,11 +50433,11 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt32Array(ctx, request) + return s.h.TestResponseIntegerUint32Nullable(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt32Array(ctx, request) + response, err = s.h.TestResponseIntegerUint32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -45201,23 +50445,23 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, w ht return } - if err := encodeTestResponseIntegerInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt32ArrayArrayRequest handles test_response_integer_int32_array_array operation. +// HandleTestResponseIntegerUint32NullableArrayRequest handles test_response_integer_uint32_nullable_array operation. // -// POST /test_response_integer_int32_array_array -func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_nullable_array +func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_array_array"), + otelogen.OperationID("test_response_integer_uint32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45241,11 +50485,11 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32ArrayArray", - ID: "test_response_integer_int32_array_array", + Name: "TestResponseIntegerUint32NullableArray", + ID: "test_response_integer_uint32_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerInt32ArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint32NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45261,12 +50505,12 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, } }() - var response [][]int32 + var response []NilUint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32ArrayArray", - OperationID: "test_response_integer_int32_array_array", + OperationName: "TestResponseIntegerUint32NullableArray", + OperationID: "test_response_integer_uint32_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -45275,7 +50519,7 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int32 + Response = []NilUint32 ) response, err = middleware.HookMiddleware[ Request, @@ -45286,11 +50530,11 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt32ArrayArray(ctx, request) + return s.h.TestResponseIntegerUint32NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt32ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45298,23 +50542,23 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt32NullableRequest handles test_response_integer_int32_nullable operation. +// HandleTestResponseIntegerUint32NullableArrayArrayRequest handles test_response_integer_uint32_nullable_array_array operation. // -// POST /test_response_integer_int32_nullable -func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_nullable_array_array +func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable"), + otelogen.OperationID("test_response_integer_uint32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45338,11 +50582,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32Nullable", - ID: "test_response_integer_int32_nullable", + Name: "TestResponseIntegerUint32NullableArrayArray", + ID: "test_response_integer_uint32_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt32NullableRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint32NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45358,12 +50602,12 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, w } }() - var response NilInt32 + var response [][]NilUint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32Nullable", - OperationID: "test_response_integer_int32_nullable", + OperationName: "TestResponseIntegerUint32NullableArrayArray", + OperationID: "test_response_integer_uint32_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -45372,7 +50616,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, w type ( Request = string Params = struct{} - Response = NilInt32 + Response = [][]NilUint32 ) response, err = middleware.HookMiddleware[ Request, @@ -45383,11 +50627,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt32Nullable(ctx, request) + return s.h.TestResponseIntegerUint32NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt32Nullable(ctx, request) + response, err = s.h.TestResponseIntegerUint32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45395,23 +50639,23 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, w return } - if err := encodeTestResponseIntegerInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt32NullableArrayRequest handles test_response_integer_int32_nullable_array operation. +// HandleTestResponseIntegerUint64Request handles test_response_integer_uint64 operation. // -// POST /test_response_integer_int32_nullable_array -func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64 +func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable_array"), + otelogen.OperationID("test_response_integer_uint64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45435,11 +50679,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32NullableArray", - ID: "test_response_integer_int32_nullable_array", + Name: "TestResponseIntegerUint64", + ID: "test_response_integer_uint64", } ) - request, close, err := s.decodeTestResponseIntegerInt32NullableArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint64Request(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45455,12 +50699,12 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri } }() - var response []NilInt32 + var response uint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32NullableArray", - OperationID: "test_response_integer_int32_nullable_array", + OperationName: "TestResponseIntegerUint64", + OperationID: "test_response_integer_uint64", Body: request, Params: map[string]any{}, Raw: r, @@ -45469,7 +50713,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilInt32 + Response = uint64 ) response, err = middleware.HookMiddleware[ Request, @@ -45480,11 +50724,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt32NullableArray(ctx, request) + return s.h.TestResponseIntegerUint64(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt32NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64(ctx, request) } if err != nil { recordError("Internal", err) @@ -45492,23 +50736,23 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64Response(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt32NullableArrayArrayRequest handles test_response_integer_int32_nullable_array_array operation. +// HandleTestResponseIntegerUint64ArrayRequest handles test_response_integer_uint64_array operation. // -// POST /test_response_integer_int32_nullable_array_array -func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_array +func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64Array", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45532,11 +50776,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32NullableArrayArray", - ID: "test_response_integer_int32_nullable_array_array", + Name: "TestResponseIntegerUint64Array", + ID: "test_response_integer_uint64_array", } ) - request, close, err := s.decodeTestResponseIntegerInt32NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint64ArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45552,12 +50796,12 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 } }() - var response [][]NilInt32 + var response []uint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32NullableArrayArray", - OperationID: "test_response_integer_int32_nullable_array_array", + OperationName: "TestResponseIntegerUint64Array", + OperationID: "test_response_integer_uint64_array", Body: request, Params: map[string]any{}, Raw: r, @@ -45566,7 +50810,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilInt32 + Response = []uint64 ) response, err = middleware.HookMiddleware[ Request, @@ -45577,11 +50821,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) + return s.h.TestResponseIntegerUint64Array(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -45589,23 +50833,23 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseIntegerInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt64Request handles test_response_integer_int64 operation. +// HandleTestResponseIntegerUint64ArrayArrayRequest handles test_response_integer_uint64_array_array operation. // -// POST /test_response_integer_int64 -func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_array_array +func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64"), + otelogen.OperationID("test_response_integer_uint64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64ArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45629,11 +50873,11 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, w http.Re } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64", - ID: "test_response_integer_int64", + Name: "TestResponseIntegerUint64ArrayArray", + ID: "test_response_integer_uint64_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64Request(r, span) + request, close, err := s.decodeTestResponseIntegerUint64ArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45649,12 +50893,12 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, w http.Re } }() - var response int64 + var response [][]uint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64", - OperationID: "test_response_integer_int64", + OperationName: "TestResponseIntegerUint64ArrayArray", + OperationID: "test_response_integer_uint64_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -45663,7 +50907,7 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, w http.Re type ( Request = string Params = struct{} - Response = int64 + Response = [][]uint64 ) response, err = middleware.HookMiddleware[ Request, @@ -45674,11 +50918,11 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, w http.Re mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt64(ctx, request) + return s.h.TestResponseIntegerUint64ArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt64(ctx, request) + response, err = s.h.TestResponseIntegerUint64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45686,23 +50930,23 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, w http.Re return } - if err := encodeTestResponseIntegerInt64Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt64ArrayRequest handles test_response_integer_int64_array operation. +// HandleTestResponseIntegerUint64NullableRequest handles test_response_integer_uint64_nullable operation. // -// POST /test_response_integer_int64_array -func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_nullable +func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_array"), + otelogen.OperationID("test_response_integer_uint64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64Nullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45726,11 +50970,11 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, w ht } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64Array", - ID: "test_response_integer_int64_array", + Name: "TestResponseIntegerUint64Nullable", + ID: "test_response_integer_uint64_nullable", } ) - request, close, err := s.decodeTestResponseIntegerInt64ArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint64NullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45746,12 +50990,12 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, w ht } }() - var response []int64 + var response NilUint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64Array", - OperationID: "test_response_integer_int64_array", + OperationName: "TestResponseIntegerUint64Nullable", + OperationID: "test_response_integer_uint64_nullable", Body: request, Params: map[string]any{}, Raw: r, @@ -45760,7 +51004,7 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, w ht type ( Request = string Params = struct{} - Response = []int64 + Response = NilUint64 ) response, err = middleware.HookMiddleware[ Request, @@ -45771,11 +51015,11 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, w ht mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt64Array(ctx, request) + return s.h.TestResponseIntegerUint64Nullable(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt64Array(ctx, request) + response, err = s.h.TestResponseIntegerUint64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -45783,23 +51027,23 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, w ht return } - if err := encodeTestResponseIntegerInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt64ArrayArrayRequest handles test_response_integer_int64_array_array operation. +// HandleTestResponseIntegerUint64NullableArrayRequest handles test_response_integer_uint64_nullable_array operation. // -// POST /test_response_integer_int64_array_array -func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_nullable_array +func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_array_array"), + otelogen.OperationID("test_response_integer_uint64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64NullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45823,11 +51067,11 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64ArrayArray", - ID: "test_response_integer_int64_array_array", + Name: "TestResponseIntegerUint64NullableArray", + ID: "test_response_integer_uint64_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64ArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint64NullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45843,12 +51087,12 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, } }() - var response [][]int64 + var response []NilUint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64ArrayArray", - OperationID: "test_response_integer_int64_array_array", + OperationName: "TestResponseIntegerUint64NullableArray", + OperationID: "test_response_integer_uint64_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -45857,7 +51101,7 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int64 + Response = []NilUint64 ) response, err = middleware.HookMiddleware[ Request, @@ -45868,11 +51112,11 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt64ArrayArray(ctx, request) + return s.h.TestResponseIntegerUint64NullableArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt64ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45880,23 +51124,23 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt64NullableRequest handles test_response_integer_int64_nullable operation. +// HandleTestResponseIntegerUint64NullableArrayArrayRequest handles test_response_integer_uint64_nullable_array_array operation. // -// POST /test_response_integer_int64_nullable -func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_nullable_array_array +func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable"), + otelogen.OperationID("test_response_integer_uint64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -45920,11 +51164,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64Nullable", - ID: "test_response_integer_int64_nullable", + Name: "TestResponseIntegerUint64NullableArrayArray", + ID: "test_response_integer_uint64_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64NullableRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUint64NullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45940,12 +51184,12 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, w } }() - var response NilInt64 + var response [][]NilUint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64Nullable", - OperationID: "test_response_integer_int64_nullable", + OperationName: "TestResponseIntegerUint64NullableArrayArray", + OperationID: "test_response_integer_uint64_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -45954,7 +51198,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, w type ( Request = string Params = struct{} - Response = NilInt64 + Response = [][]NilUint64 ) response, err = middleware.HookMiddleware[ Request, @@ -45965,11 +51209,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt64Nullable(ctx, request) + return s.h.TestResponseIntegerUint64NullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt64Nullable(ctx, request) + response, err = s.h.TestResponseIntegerUint64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45977,23 +51221,23 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, w return } - if err := encodeTestResponseIntegerInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt64NullableArrayRequest handles test_response_integer_int64_nullable_array operation. +// HandleTestResponseIntegerUintArrayRequest handles test_response_integer_uint_array operation. // -// POST /test_response_integer_int64_nullable_array -func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_array +func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable_array"), + otelogen.OperationID("test_response_integer_uint_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -46017,11 +51261,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64NullableArray", - ID: "test_response_integer_int64_nullable_array", + Name: "TestResponseIntegerUintArray", + ID: "test_response_integer_uint_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64NullableArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUintArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46037,12 +51281,12 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri } }() - var response []NilInt64 + var response []uint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64NullableArray", - OperationID: "test_response_integer_int64_nullable_array", + OperationName: "TestResponseIntegerUintArray", + OperationID: "test_response_integer_uint_array", Body: request, Params: map[string]any{}, Raw: r, @@ -46051,7 +51295,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilInt64 + Response = []uint ) response, err = middleware.HookMiddleware[ Request, @@ -46062,11 +51306,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt64NullableArray(ctx, request) + return s.h.TestResponseIntegerUintArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt64NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUintArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46074,23 +51318,23 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerInt64NullableArrayArrayRequest handles test_response_integer_int64_nullable_array_array operation. +// HandleTestResponseIntegerUintArrayArrayRequest handles test_response_integer_uint_array_array operation. // -// POST /test_response_integer_int64_nullable_array_array -func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_array_array +func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -46114,11 +51358,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64NullableArrayArray", - ID: "test_response_integer_int64_nullable_array_array", + Name: "TestResponseIntegerUintArrayArray", + ID: "test_response_integer_uint_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64NullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUintArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46134,12 +51378,12 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 } }() - var response [][]NilInt64 + var response [][]uint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64NullableArrayArray", - OperationID: "test_response_integer_int64_nullable_array_array", + OperationName: "TestResponseIntegerUintArrayArray", + OperationID: "test_response_integer_uint_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -46148,7 +51392,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilInt64 + Response = [][]uint ) response, err = middleware.HookMiddleware[ Request, @@ -46159,11 +51403,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) + return s.h.TestResponseIntegerUintArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUintArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46171,23 +51415,23 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseIntegerInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerNullableRequest handles test_response_integer_nullable operation. +// HandleTestResponseIntegerUintNullableRequest handles test_response_integer_uint_nullable operation. // -// POST /test_response_integer_nullable -func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_nullable +func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable"), + otelogen.OperationID("test_response_integer_uint_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullable", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -46211,11 +51455,11 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, w http } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerNullable", - ID: "test_response_integer_nullable", + Name: "TestResponseIntegerUintNullable", + ID: "test_response_integer_uint_nullable", } ) - request, close, err := s.decodeTestResponseIntegerNullableRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUintNullableRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46231,12 +51475,12 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, w http } }() - var response NilInt + var response NilUint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerNullable", - OperationID: "test_response_integer_nullable", + OperationName: "TestResponseIntegerUintNullable", + OperationID: "test_response_integer_uint_nullable", Body: request, Params: map[string]any{}, Raw: r, @@ -46245,7 +51489,7 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, w http type ( Request = string Params = struct{} - Response = NilInt + Response = NilUint ) response, err = middleware.HookMiddleware[ Request, @@ -46256,11 +51500,11 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, w http mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerNullable(ctx, request) + return s.h.TestResponseIntegerUintNullable(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerNullable(ctx, request) + response, err = s.h.TestResponseIntegerUintNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -46268,23 +51512,23 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, w http return } - if err := encodeTestResponseIntegerNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerNullableArrayRequest handles test_response_integer_nullable_array operation. +// HandleTestResponseIntegerUintNullableArrayRequest handles test_response_integer_uint_nullable_array operation. // -// POST /test_response_integer_nullable_array -func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_nullable_array +func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable_array"), + otelogen.OperationID("test_response_integer_uint_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullableArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -46308,11 +51552,11 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, w } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerNullableArray", - ID: "test_response_integer_nullable_array", + Name: "TestResponseIntegerUintNullableArray", + ID: "test_response_integer_uint_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerNullableArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUintNullableArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46328,12 +51572,12 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, w } }() - var response []NilInt + var response []NilUint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerNullableArray", - OperationID: "test_response_integer_nullable_array", + OperationName: "TestResponseIntegerUintNullableArray", + OperationID: "test_response_integer_uint_nullable_array", Body: request, Params: map[string]any{}, Raw: r, @@ -46342,7 +51586,7 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, w type ( Request = string Params = struct{} - Response = []NilInt + Response = []NilUint ) response, err = middleware.HookMiddleware[ Request, @@ -46353,11 +51597,11 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, w mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerNullableArray(ctx, request) + return s.h.TestResponseIntegerUintNullableArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUintNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46365,23 +51609,23 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, w return } - if err := encodeTestResponseIntegerNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return } } -// HandleTestResponseIntegerNullableArrayArrayRequest handles test_response_integer_nullable_array_array operation. +// HandleTestResponseIntegerUintNullableArrayArrayRequest handles test_response_integer_uint_nullable_array_array operation. // -// POST /test_response_integer_nullable_array_array -func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_nullable_array_array +func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0]string, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullableArrayArray", trace.WithAttributes(otelAttrs...), trace.WithSpanKind(trace.SpanKindServer), ) @@ -46405,11 +51649,11 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerNullableArrayArray", - ID: "test_response_integer_nullable_array_array", + Name: "TestResponseIntegerUintNullableArrayArray", + ID: "test_response_integer_uint_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerNullableArrayArrayRequest(r, span) + request, close, err := s.decodeTestResponseIntegerUintNullableArrayArrayRequest(r, span) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46425,12 +51669,12 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri } }() - var response [][]NilInt + var response [][]NilUint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerNullableArrayArray", - OperationID: "test_response_integer_nullable_array_array", + OperationName: "TestResponseIntegerUintNullableArrayArray", + OperationID: "test_response_integer_uint_nullable_array_array", Body: request, Params: map[string]any{}, Raw: r, @@ -46439,7 +51683,7 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = [][]NilInt + Response = [][]NilUint ) response, err = middleware.HookMiddleware[ Request, @@ -46450,11 +51694,11 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (Response, error) { - return s.h.TestResponseIntegerNullableArrayArray(ctx, request) + return s.h.TestResponseIntegerUintNullableArrayArray(ctx, request) }, ) } else { - response, err = s.h.TestResponseIntegerNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUintNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46462,7 +51706,7 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) s.cfg.ErrorHandler(ctx, w, r, err) return diff --git a/examples/ex_test_format/oas_json_gen.go b/examples/ex_test_format/oas_json_gen.go index b5b3fa131..ec084a942 100644 --- a/examples/ex_test_format/oas_json_gen.go +++ b/examples/ex_test_format/oas_json_gen.go @@ -1109,6 +1109,144 @@ func (s *NilUUID) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes uint as json. +func (o NilUint) Encode(e *jx.Encoder) { + if o.Null { + e.Null() + return + } + e.UInt(uint(o.Value)) +} + +// Decode decodes uint from json. +func (o *NilUint) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode NilUint to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v uint + o.Value = v + o.Null = true + return nil + } + o.Null = false + v, err := d.UInt() + if err != nil { + return err + } + o.Value = uint(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NilUint) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NilUint) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes uint32 as json. +func (o NilUint32) Encode(e *jx.Encoder) { + if o.Null { + e.Null() + return + } + e.UInt32(uint32(o.Value)) +} + +// Decode decodes uint32 from json. +func (o *NilUint32) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode NilUint32 to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v uint32 + o.Value = v + o.Null = true + return nil + } + o.Null = false + v, err := d.UInt32() + if err != nil { + return err + } + o.Value = uint32(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NilUint32) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NilUint32) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes uint64 as json. +func (o NilUint64) Encode(e *jx.Encoder) { + if o.Null { + e.Null() + return + } + e.UInt64(uint64(o.Value)) +} + +// Decode decodes uint64 from json. +func (o *NilUint64) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode NilUint64 to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v uint64 + o.Value = v + o.Null = true + return nil + } + o.Null = false + v, err := d.UInt64() + if err != nil { + return err + } + o.Value = uint64(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NilUint64) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NilUint64) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes time.Time as json. func (o NilUnixMicro) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { if o.Null { @@ -2886,6 +3024,159 @@ func (s *OptNilUUID) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes uint as json. +func (o OptNilUint) Encode(e *jx.Encoder) { + if !o.Set { + return + } + if o.Null { + e.Null() + return + } + e.UInt(uint(o.Value)) +} + +// Decode decodes uint from json. +func (o *OptNilUint) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptNilUint to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v uint + o.Value = v + o.Set = true + o.Null = true + return nil + } + o.Set = true + o.Null = false + v, err := d.UInt() + if err != nil { + return err + } + o.Value = uint(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptNilUint) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptNilUint) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes uint32 as json. +func (o OptNilUint32) Encode(e *jx.Encoder) { + if !o.Set { + return + } + if o.Null { + e.Null() + return + } + e.UInt32(uint32(o.Value)) +} + +// Decode decodes uint32 from json. +func (o *OptNilUint32) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptNilUint32 to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v uint32 + o.Value = v + o.Set = true + o.Null = true + return nil + } + o.Set = true + o.Null = false + v, err := d.UInt32() + if err != nil { + return err + } + o.Value = uint32(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptNilUint32) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptNilUint32) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes uint64 as json. +func (o OptNilUint64) Encode(e *jx.Encoder) { + if !o.Set { + return + } + if o.Null { + e.Null() + return + } + e.UInt64(uint64(o.Value)) +} + +// Decode decodes uint64 from json. +func (o *OptNilUint64) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptNilUint64 to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v uint64 + o.Value = v + o.Set = true + o.Null = true + return nil + } + o.Set = true + o.Null = false + v, err := d.UInt64() + if err != nil { + return err + } + o.Value = uint64(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptNilUint64) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptNilUint64) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes time.Time as json. func (o OptNilUnixMicro) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { if !o.Set { @@ -3506,82 +3797,187 @@ func (s *OptUUID) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode encodes time.Time as json. -func (o OptUnixMicro) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { +// Encode encodes uint as json. +func (o OptUint) Encode(e *jx.Encoder) { if !o.Set { return } - format(e, o.Value) + e.UInt(uint(o.Value)) } -// Decode decodes time.Time from json. -func (o *OptUnixMicro) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error { +// Decode decodes uint from json. +func (o *OptUint) Decode(d *jx.Decoder) error { if o == nil { - return errors.New("invalid: unable to decode OptUnixMicro to nil") + return errors.New("invalid: unable to decode OptUint to nil") } o.Set = true - v, err := format(d) + v, err := d.UInt() if err != nil { return err } - o.Value = v + o.Value = uint(v) return nil } // MarshalJSON implements stdjson.Marshaler. -func (s OptUnixMicro) MarshalJSON() ([]byte, error) { +func (s OptUint) MarshalJSON() ([]byte, error) { e := jx.Encoder{} - s.Encode(&e, json.EncodeUnixMicro) + s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptUnixMicro) UnmarshalJSON(data []byte) error { +func (s *OptUint) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) - return s.Decode(d, json.DecodeUnixMicro) + return s.Decode(d) } -// Encode encodes time.Time as json. -func (o OptUnixMilli) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { +// Encode encodes uint32 as json. +func (o OptUint32) Encode(e *jx.Encoder) { if !o.Set { return } - format(e, o.Value) + e.UInt32(uint32(o.Value)) } -// Decode decodes time.Time from json. -func (o *OptUnixMilli) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error { +// Decode decodes uint32 from json. +func (o *OptUint32) Decode(d *jx.Decoder) error { if o == nil { - return errors.New("invalid: unable to decode OptUnixMilli to nil") + return errors.New("invalid: unable to decode OptUint32 to nil") } o.Set = true - v, err := format(d) + v, err := d.UInt32() if err != nil { return err } - o.Value = v + o.Value = uint32(v) return nil } // MarshalJSON implements stdjson.Marshaler. -func (s OptUnixMilli) MarshalJSON() ([]byte, error) { +func (s OptUint32) MarshalJSON() ([]byte, error) { e := jx.Encoder{} - s.Encode(&e, json.EncodeUnixMilli) + s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptUnixMilli) UnmarshalJSON(data []byte) error { +func (s *OptUint32) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) - return s.Decode(d, json.DecodeUnixMilli) + return s.Decode(d) } -// Encode encodes time.Time as json. -func (o OptUnixNano) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { +// Encode encodes uint64 as json. +func (o OptUint64) Encode(e *jx.Encoder) { if !o.Set { return } - format(e, o.Value) + e.UInt64(uint64(o.Value)) +} + +// Decode decodes uint64 from json. +func (o *OptUint64) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptUint64 to nil") + } + o.Set = true + v, err := d.UInt64() + if err != nil { + return err + } + o.Value = uint64(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptUint64) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptUint64) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes time.Time as json. +func (o OptUnixMicro) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { + if !o.Set { + return + } + format(e, o.Value) +} + +// Decode decodes time.Time from json. +func (o *OptUnixMicro) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error { + if o == nil { + return errors.New("invalid: unable to decode OptUnixMicro to nil") + } + o.Set = true + v, err := format(d) + if err != nil { + return err + } + o.Value = v + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptUnixMicro) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e, json.EncodeUnixMicro) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptUnixMicro) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d, json.DecodeUnixMicro) +} + +// Encode encodes time.Time as json. +func (o OptUnixMilli) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { + if !o.Set { + return + } + format(e, o.Value) +} + +// Decode decodes time.Time from json. +func (o *OptUnixMilli) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error { + if o == nil { + return errors.New("invalid: unable to decode OptUnixMilli to nil") + } + o.Set = true + v, err := format(d) + if err != nil { + return err + } + o.Value = v + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptUnixMilli) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e, json.EncodeUnixMilli) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptUnixMilli) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d, json.DecodeUnixMilli) +} + +// Encode encodes time.Time as json. +func (o OptUnixNano) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) { + if !o.Set { + return + } + format(e, o.Value) } // Decode decodes time.Time from json. @@ -3754,6 +4150,33 @@ func (s TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + + e.FieldStart("required_array_integer_uint") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint { + e.UInt(elem) + } + e.ArrEnd() + } + { + + e.FieldStart("required_array_integer_uint32") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint32 { + e.UInt32(elem) + } + e.ArrEnd() + } + { + + e.FieldStart("required_array_integer_uint64") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint64 { + e.UInt64(elem) + } + e.ArrEnd() + } { e.FieldStart("required_array_integer_unix") @@ -4124,6 +4547,45 @@ func (s TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + + e.FieldStart("required_double_array_integer_uint") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerUint { + e.ArrStart() + for _, elem := range elem { + e.UInt(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + { + + e.FieldStart("required_double_array_integer_uint32") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerUint32 { + e.ArrStart() + for _, elem := range elem { + e.UInt32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + { + + e.FieldStart("required_double_array_integer_uint64") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerUint64 { + e.ArrStart() + for _, elem := range elem { + e.UInt64(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } { e.FieldStart("required_double_array_integer_unix") @@ -4569,6 +5031,21 @@ func (s TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { e.FieldStart("required_integer_int64") e.Int64(s.RequiredIntegerInt64) } + { + + e.FieldStart("required_integer_uint") + e.UInt(s.RequiredIntegerUint) + } + { + + e.FieldStart("required_integer_uint32") + e.UInt32(s.RequiredIntegerUint32) + } + { + + e.FieldStart("required_integer_uint64") + e.UInt64(s.RequiredIntegerUint64) + } { e.FieldStart("required_integer_unix") @@ -4794,6 +5271,36 @@ func (s TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalArrayIntegerUint != nil { + e.FieldStart("optional_array_integer_uint") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint { + e.UInt(elem) + } + e.ArrEnd() + } + } + { + if s.OptionalArrayIntegerUint32 != nil { + e.FieldStart("optional_array_integer_uint32") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint32 { + e.UInt32(elem) + } + e.ArrEnd() + } + } + { + if s.OptionalArrayIntegerUint64 != nil { + e.FieldStart("optional_array_integer_uint64") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint64 { + e.UInt64(elem) + } + e.ArrEnd() + } + } { if s.OptionalArrayIntegerUnix != nil { e.FieldStart("optional_array_integer_unix") @@ -5203,6 +5710,48 @@ func (s TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalDoubleArrayIntegerUint != nil { + e.FieldStart("optional_double_array_integer_uint") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerUint { + e.ArrStart() + for _, elem := range elem { + e.UInt(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + { + if s.OptionalDoubleArrayIntegerUint32 != nil { + e.FieldStart("optional_double_array_integer_uint32") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerUint32 { + e.ArrStart() + for _, elem := range elem { + e.UInt32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + { + if s.OptionalDoubleArrayIntegerUint64 != nil { + e.FieldStart("optional_double_array_integer_uint64") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerUint64 { + e.ArrStart() + for _, elem := range elem { + e.UInt64(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } { if s.OptionalDoubleArrayIntegerUnix != nil { e.FieldStart("optional_double_array_integer_unix") @@ -5684,6 +6233,24 @@ func (s TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { s.OptionalIntegerInt64.Encode(e) } } + { + if s.OptionalIntegerUint.Set { + e.FieldStart("optional_integer_uint") + s.OptionalIntegerUint.Encode(e) + } + } + { + if s.OptionalIntegerUint32.Set { + e.FieldStart("optional_integer_uint32") + s.OptionalIntegerUint32.Encode(e) + } + } + { + if s.OptionalIntegerUint64.Set { + e.FieldStart("optional_integer_uint64") + s.OptionalIntegerUint64.Encode(e) + } + } { if s.OptionalIntegerUnix.Set { e.FieldStart("optional_integer_unix") @@ -5883,235 +6450,253 @@ func (s TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfTestRequestFormatTestReq = [228]string{ +var jsonFieldsNameOfTestRequestFormatTestReq = [246]string{ 0: "required_any", 1: "required_array_any", 2: "required_array_boolean", 3: "required_array_integer", 4: "required_array_integer_int32", 5: "required_array_integer_int64", - 6: "required_array_integer_unix", - 7: "required_array_integer_unix-micro", - 8: "required_array_integer_unix-milli", - 9: "required_array_integer_unix-nano", - 10: "required_array_integer_unix-seconds", - 11: "required_array_null", - 12: "required_array_number", - 13: "required_array_number_double", - 14: "required_array_number_float", - 15: "required_array_number_int32", - 16: "required_array_number_int64", - 17: "required_array_string", - 18: "required_array_string_binary", - 19: "required_array_string_byte", - 20: "required_array_string_date", - 21: "required_array_string_date-time", - 22: "required_array_string_duration", - 23: "required_array_string_email", - 24: "required_array_string_hostname", - 25: "required_array_string_int32", - 26: "required_array_string_int64", - 27: "required_array_string_ip", - 28: "required_array_string_ipv4", - 29: "required_array_string_ipv6", - 30: "required_array_string_password", - 31: "required_array_string_time", - 32: "required_array_string_unix", - 33: "required_array_string_unix-micro", - 34: "required_array_string_unix-milli", - 35: "required_array_string_unix-nano", - 36: "required_array_string_unix-seconds", - 37: "required_array_string_uri", - 38: "required_array_string_uuid", - 39: "required_boolean", - 40: "required_double_array_any", - 41: "required_double_array_boolean", - 42: "required_double_array_integer", - 43: "required_double_array_integer_int32", - 44: "required_double_array_integer_int64", - 45: "required_double_array_integer_unix", - 46: "required_double_array_integer_unix-micro", - 47: "required_double_array_integer_unix-milli", - 48: "required_double_array_integer_unix-nano", - 49: "required_double_array_integer_unix-seconds", - 50: "required_double_array_null", - 51: "required_double_array_number", - 52: "required_double_array_number_double", - 53: "required_double_array_number_float", - 54: "required_double_array_number_int32", - 55: "required_double_array_number_int64", - 56: "required_double_array_string", - 57: "required_double_array_string_binary", - 58: "required_double_array_string_byte", - 59: "required_double_array_string_date", - 60: "required_double_array_string_date-time", - 61: "required_double_array_string_duration", - 62: "required_double_array_string_email", - 63: "required_double_array_string_hostname", - 64: "required_double_array_string_int32", - 65: "required_double_array_string_int64", - 66: "required_double_array_string_ip", - 67: "required_double_array_string_ipv4", - 68: "required_double_array_string_ipv6", - 69: "required_double_array_string_password", - 70: "required_double_array_string_time", - 71: "required_double_array_string_unix", - 72: "required_double_array_string_unix-micro", - 73: "required_double_array_string_unix-milli", - 74: "required_double_array_string_unix-nano", - 75: "required_double_array_string_unix-seconds", - 76: "required_double_array_string_uri", - 77: "required_double_array_string_uuid", - 78: "required_integer", - 79: "required_integer_int32", - 80: "required_integer_int64", - 81: "required_integer_unix", - 82: "required_integer_unix-micro", - 83: "required_integer_unix-milli", - 84: "required_integer_unix-nano", - 85: "required_integer_unix-seconds", - 86: "required_null", - 87: "required_number", - 88: "required_number_double", - 89: "required_number_float", - 90: "required_number_int32", - 91: "required_number_int64", - 92: "required_string", - 93: "required_string_binary", - 94: "required_string_byte", - 95: "required_string_date", - 96: "required_string_date-time", - 97: "required_string_duration", - 98: "required_string_email", - 99: "required_string_hostname", - 100: "required_string_int32", - 101: "required_string_int64", - 102: "required_string_ip", - 103: "required_string_ipv4", - 104: "required_string_ipv6", - 105: "required_string_password", - 106: "required_string_time", - 107: "required_string_unix", - 108: "required_string_unix-micro", - 109: "required_string_unix-milli", - 110: "required_string_unix-nano", - 111: "required_string_unix-seconds", - 112: "required_string_uri", - 113: "required_string_uuid", - 114: "optional_any", - 115: "optional_array_any", - 116: "optional_array_boolean", - 117: "optional_array_integer", - 118: "optional_array_integer_int32", - 119: "optional_array_integer_int64", - 120: "optional_array_integer_unix", - 121: "optional_array_integer_unix-micro", - 122: "optional_array_integer_unix-milli", - 123: "optional_array_integer_unix-nano", - 124: "optional_array_integer_unix-seconds", - 125: "optional_array_null", - 126: "optional_array_number", - 127: "optional_array_number_double", - 128: "optional_array_number_float", - 129: "optional_array_number_int32", - 130: "optional_array_number_int64", - 131: "optional_array_string", - 132: "optional_array_string_binary", - 133: "optional_array_string_byte", - 134: "optional_array_string_date", - 135: "optional_array_string_date-time", - 136: "optional_array_string_duration", - 137: "optional_array_string_email", - 138: "optional_array_string_hostname", - 139: "optional_array_string_int32", - 140: "optional_array_string_int64", - 141: "optional_array_string_ip", - 142: "optional_array_string_ipv4", - 143: "optional_array_string_ipv6", - 144: "optional_array_string_password", - 145: "optional_array_string_time", - 146: "optional_array_string_unix", - 147: "optional_array_string_unix-micro", - 148: "optional_array_string_unix-milli", - 149: "optional_array_string_unix-nano", - 150: "optional_array_string_unix-seconds", - 151: "optional_array_string_uri", - 152: "optional_array_string_uuid", - 153: "optional_boolean", - 154: "optional_double_array_any", - 155: "optional_double_array_boolean", - 156: "optional_double_array_integer", - 157: "optional_double_array_integer_int32", - 158: "optional_double_array_integer_int64", - 159: "optional_double_array_integer_unix", - 160: "optional_double_array_integer_unix-micro", - 161: "optional_double_array_integer_unix-milli", - 162: "optional_double_array_integer_unix-nano", - 163: "optional_double_array_integer_unix-seconds", - 164: "optional_double_array_null", - 165: "optional_double_array_number", - 166: "optional_double_array_number_double", - 167: "optional_double_array_number_float", - 168: "optional_double_array_number_int32", - 169: "optional_double_array_number_int64", - 170: "optional_double_array_string", - 171: "optional_double_array_string_binary", - 172: "optional_double_array_string_byte", - 173: "optional_double_array_string_date", - 174: "optional_double_array_string_date-time", - 175: "optional_double_array_string_duration", - 176: "optional_double_array_string_email", - 177: "optional_double_array_string_hostname", - 178: "optional_double_array_string_int32", - 179: "optional_double_array_string_int64", - 180: "optional_double_array_string_ip", - 181: "optional_double_array_string_ipv4", - 182: "optional_double_array_string_ipv6", - 183: "optional_double_array_string_password", - 184: "optional_double_array_string_time", - 185: "optional_double_array_string_unix", - 186: "optional_double_array_string_unix-micro", - 187: "optional_double_array_string_unix-milli", - 188: "optional_double_array_string_unix-nano", - 189: "optional_double_array_string_unix-seconds", - 190: "optional_double_array_string_uri", - 191: "optional_double_array_string_uuid", - 192: "optional_integer", - 193: "optional_integer_int32", - 194: "optional_integer_int64", - 195: "optional_integer_unix", - 196: "optional_integer_unix-micro", - 197: "optional_integer_unix-milli", - 198: "optional_integer_unix-nano", - 199: "optional_integer_unix-seconds", - 200: "optional_null", - 201: "optional_number", - 202: "optional_number_double", - 203: "optional_number_float", - 204: "optional_number_int32", - 205: "optional_number_int64", - 206: "optional_string", - 207: "optional_string_binary", - 208: "optional_string_byte", - 209: "optional_string_date", - 210: "optional_string_date-time", - 211: "optional_string_duration", - 212: "optional_string_email", - 213: "optional_string_hostname", - 214: "optional_string_int32", - 215: "optional_string_int64", - 216: "optional_string_ip", - 217: "optional_string_ipv4", - 218: "optional_string_ipv6", - 219: "optional_string_password", - 220: "optional_string_time", - 221: "optional_string_unix", - 222: "optional_string_unix-micro", - 223: "optional_string_unix-milli", - 224: "optional_string_unix-nano", - 225: "optional_string_unix-seconds", - 226: "optional_string_uri", - 227: "optional_string_uuid", + 6: "required_array_integer_uint", + 7: "required_array_integer_uint32", + 8: "required_array_integer_uint64", + 9: "required_array_integer_unix", + 10: "required_array_integer_unix-micro", + 11: "required_array_integer_unix-milli", + 12: "required_array_integer_unix-nano", + 13: "required_array_integer_unix-seconds", + 14: "required_array_null", + 15: "required_array_number", + 16: "required_array_number_double", + 17: "required_array_number_float", + 18: "required_array_number_int32", + 19: "required_array_number_int64", + 20: "required_array_string", + 21: "required_array_string_binary", + 22: "required_array_string_byte", + 23: "required_array_string_date", + 24: "required_array_string_date-time", + 25: "required_array_string_duration", + 26: "required_array_string_email", + 27: "required_array_string_hostname", + 28: "required_array_string_int32", + 29: "required_array_string_int64", + 30: "required_array_string_ip", + 31: "required_array_string_ipv4", + 32: "required_array_string_ipv6", + 33: "required_array_string_password", + 34: "required_array_string_time", + 35: "required_array_string_unix", + 36: "required_array_string_unix-micro", + 37: "required_array_string_unix-milli", + 38: "required_array_string_unix-nano", + 39: "required_array_string_unix-seconds", + 40: "required_array_string_uri", + 41: "required_array_string_uuid", + 42: "required_boolean", + 43: "required_double_array_any", + 44: "required_double_array_boolean", + 45: "required_double_array_integer", + 46: "required_double_array_integer_int32", + 47: "required_double_array_integer_int64", + 48: "required_double_array_integer_uint", + 49: "required_double_array_integer_uint32", + 50: "required_double_array_integer_uint64", + 51: "required_double_array_integer_unix", + 52: "required_double_array_integer_unix-micro", + 53: "required_double_array_integer_unix-milli", + 54: "required_double_array_integer_unix-nano", + 55: "required_double_array_integer_unix-seconds", + 56: "required_double_array_null", + 57: "required_double_array_number", + 58: "required_double_array_number_double", + 59: "required_double_array_number_float", + 60: "required_double_array_number_int32", + 61: "required_double_array_number_int64", + 62: "required_double_array_string", + 63: "required_double_array_string_binary", + 64: "required_double_array_string_byte", + 65: "required_double_array_string_date", + 66: "required_double_array_string_date-time", + 67: "required_double_array_string_duration", + 68: "required_double_array_string_email", + 69: "required_double_array_string_hostname", + 70: "required_double_array_string_int32", + 71: "required_double_array_string_int64", + 72: "required_double_array_string_ip", + 73: "required_double_array_string_ipv4", + 74: "required_double_array_string_ipv6", + 75: "required_double_array_string_password", + 76: "required_double_array_string_time", + 77: "required_double_array_string_unix", + 78: "required_double_array_string_unix-micro", + 79: "required_double_array_string_unix-milli", + 80: "required_double_array_string_unix-nano", + 81: "required_double_array_string_unix-seconds", + 82: "required_double_array_string_uri", + 83: "required_double_array_string_uuid", + 84: "required_integer", + 85: "required_integer_int32", + 86: "required_integer_int64", + 87: "required_integer_uint", + 88: "required_integer_uint32", + 89: "required_integer_uint64", + 90: "required_integer_unix", + 91: "required_integer_unix-micro", + 92: "required_integer_unix-milli", + 93: "required_integer_unix-nano", + 94: "required_integer_unix-seconds", + 95: "required_null", + 96: "required_number", + 97: "required_number_double", + 98: "required_number_float", + 99: "required_number_int32", + 100: "required_number_int64", + 101: "required_string", + 102: "required_string_binary", + 103: "required_string_byte", + 104: "required_string_date", + 105: "required_string_date-time", + 106: "required_string_duration", + 107: "required_string_email", + 108: "required_string_hostname", + 109: "required_string_int32", + 110: "required_string_int64", + 111: "required_string_ip", + 112: "required_string_ipv4", + 113: "required_string_ipv6", + 114: "required_string_password", + 115: "required_string_time", + 116: "required_string_unix", + 117: "required_string_unix-micro", + 118: "required_string_unix-milli", + 119: "required_string_unix-nano", + 120: "required_string_unix-seconds", + 121: "required_string_uri", + 122: "required_string_uuid", + 123: "optional_any", + 124: "optional_array_any", + 125: "optional_array_boolean", + 126: "optional_array_integer", + 127: "optional_array_integer_int32", + 128: "optional_array_integer_int64", + 129: "optional_array_integer_uint", + 130: "optional_array_integer_uint32", + 131: "optional_array_integer_uint64", + 132: "optional_array_integer_unix", + 133: "optional_array_integer_unix-micro", + 134: "optional_array_integer_unix-milli", + 135: "optional_array_integer_unix-nano", + 136: "optional_array_integer_unix-seconds", + 137: "optional_array_null", + 138: "optional_array_number", + 139: "optional_array_number_double", + 140: "optional_array_number_float", + 141: "optional_array_number_int32", + 142: "optional_array_number_int64", + 143: "optional_array_string", + 144: "optional_array_string_binary", + 145: "optional_array_string_byte", + 146: "optional_array_string_date", + 147: "optional_array_string_date-time", + 148: "optional_array_string_duration", + 149: "optional_array_string_email", + 150: "optional_array_string_hostname", + 151: "optional_array_string_int32", + 152: "optional_array_string_int64", + 153: "optional_array_string_ip", + 154: "optional_array_string_ipv4", + 155: "optional_array_string_ipv6", + 156: "optional_array_string_password", + 157: "optional_array_string_time", + 158: "optional_array_string_unix", + 159: "optional_array_string_unix-micro", + 160: "optional_array_string_unix-milli", + 161: "optional_array_string_unix-nano", + 162: "optional_array_string_unix-seconds", + 163: "optional_array_string_uri", + 164: "optional_array_string_uuid", + 165: "optional_boolean", + 166: "optional_double_array_any", + 167: "optional_double_array_boolean", + 168: "optional_double_array_integer", + 169: "optional_double_array_integer_int32", + 170: "optional_double_array_integer_int64", + 171: "optional_double_array_integer_uint", + 172: "optional_double_array_integer_uint32", + 173: "optional_double_array_integer_uint64", + 174: "optional_double_array_integer_unix", + 175: "optional_double_array_integer_unix-micro", + 176: "optional_double_array_integer_unix-milli", + 177: "optional_double_array_integer_unix-nano", + 178: "optional_double_array_integer_unix-seconds", + 179: "optional_double_array_null", + 180: "optional_double_array_number", + 181: "optional_double_array_number_double", + 182: "optional_double_array_number_float", + 183: "optional_double_array_number_int32", + 184: "optional_double_array_number_int64", + 185: "optional_double_array_string", + 186: "optional_double_array_string_binary", + 187: "optional_double_array_string_byte", + 188: "optional_double_array_string_date", + 189: "optional_double_array_string_date-time", + 190: "optional_double_array_string_duration", + 191: "optional_double_array_string_email", + 192: "optional_double_array_string_hostname", + 193: "optional_double_array_string_int32", + 194: "optional_double_array_string_int64", + 195: "optional_double_array_string_ip", + 196: "optional_double_array_string_ipv4", + 197: "optional_double_array_string_ipv6", + 198: "optional_double_array_string_password", + 199: "optional_double_array_string_time", + 200: "optional_double_array_string_unix", + 201: "optional_double_array_string_unix-micro", + 202: "optional_double_array_string_unix-milli", + 203: "optional_double_array_string_unix-nano", + 204: "optional_double_array_string_unix-seconds", + 205: "optional_double_array_string_uri", + 206: "optional_double_array_string_uuid", + 207: "optional_integer", + 208: "optional_integer_int32", + 209: "optional_integer_int64", + 210: "optional_integer_uint", + 211: "optional_integer_uint32", + 212: "optional_integer_uint64", + 213: "optional_integer_unix", + 214: "optional_integer_unix-micro", + 215: "optional_integer_unix-milli", + 216: "optional_integer_unix-nano", + 217: "optional_integer_unix-seconds", + 218: "optional_null", + 219: "optional_number", + 220: "optional_number_double", + 221: "optional_number_float", + 222: "optional_number_int32", + 223: "optional_number_int64", + 224: "optional_string", + 225: "optional_string_binary", + 226: "optional_string_byte", + 227: "optional_string_date", + 228: "optional_string_date-time", + 229: "optional_string_duration", + 230: "optional_string_email", + 231: "optional_string_hostname", + 232: "optional_string_int32", + 233: "optional_string_int64", + 234: "optional_string_ip", + 235: "optional_string_ipv4", + 236: "optional_string_ipv6", + 237: "optional_string_password", + 238: "optional_string_time", + 239: "optional_string_unix", + 240: "optional_string_unix-micro", + 241: "optional_string_unix-milli", + 242: "optional_string_unix-nano", + 243: "optional_string_unix-seconds", + 244: "optional_string_uri", + 245: "optional_string_uuid", } // Decode decodes TestRequestFormatTestReq from json. @@ -6119,7 +6704,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode TestRequestFormatTestReq to nil") } - var requiredBitSet [29]uint8 + var requiredBitSet [31]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -6235,110 +6820,170 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_array_integer_int64\"") } - case "required_array_integer_unix": + case "required_array_integer_uint": requiredBitSet[0] |= 1 << 6 if err := func() error { - s.RequiredArrayIntegerUnix = make([]time.Time, 0) + s.RequiredArrayIntegerUint = make([]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixSeconds(d) - elem = v + var elem uint + v, err := d.UInt() + elem = uint(v) if err != nil { return err } - s.RequiredArrayIntegerUnix = append(s.RequiredArrayIntegerUnix, elem) + s.RequiredArrayIntegerUint = append(s.RequiredArrayIntegerUint, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"required_array_integer_unix\"") + return errors.Wrap(err, "decode field \"required_array_integer_uint\"") } - case "required_array_integer_unix-micro": + case "required_array_integer_uint32": requiredBitSet[0] |= 1 << 7 if err := func() error { - s.RequiredArrayIntegerUnixMinusMicro = make([]time.Time, 0) + s.RequiredArrayIntegerUint32 = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixMicro(d) - elem = v + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) if err != nil { return err } - s.RequiredArrayIntegerUnixMinusMicro = append(s.RequiredArrayIntegerUnixMinusMicro, elem) + s.RequiredArrayIntegerUint32 = append(s.RequiredArrayIntegerUint32, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"required_array_integer_unix-micro\"") + return errors.Wrap(err, "decode field \"required_array_integer_uint32\"") } - case "required_array_integer_unix-milli": + case "required_array_integer_uint64": requiredBitSet[1] |= 1 << 0 if err := func() error { - s.RequiredArrayIntegerUnixMinusMilli = make([]time.Time, 0) + s.RequiredArrayIntegerUint64 = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixMilli(d) - elem = v + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) if err != nil { return err } - s.RequiredArrayIntegerUnixMinusMilli = append(s.RequiredArrayIntegerUnixMinusMilli, elem) + s.RequiredArrayIntegerUint64 = append(s.RequiredArrayIntegerUint64, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"required_array_integer_unix-milli\"") + return errors.Wrap(err, "decode field \"required_array_integer_uint64\"") } - case "required_array_integer_unix-nano": + case "required_array_integer_unix": requiredBitSet[1] |= 1 << 1 if err := func() error { - s.RequiredArrayIntegerUnixMinusNano = make([]time.Time, 0) + s.RequiredArrayIntegerUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem time.Time - v, err := json.DecodeUnixNano(d) + v, err := json.DecodeUnixSeconds(d) elem = v if err != nil { return err } - s.RequiredArrayIntegerUnixMinusNano = append(s.RequiredArrayIntegerUnixMinusNano, elem) + s.RequiredArrayIntegerUnix = append(s.RequiredArrayIntegerUnix, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"required_array_integer_unix-nano\"") + return errors.Wrap(err, "decode field \"required_array_integer_unix\"") } - case "required_array_integer_unix-seconds": + case "required_array_integer_unix-micro": requiredBitSet[1] |= 1 << 2 if err := func() error { - s.RequiredArrayIntegerUnixMinusSeconds = make([]time.Time, 0) + s.RequiredArrayIntegerUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem time.Time - v, err := json.DecodeUnixSeconds(d) + v, err := json.DecodeUnixMicro(d) elem = v if err != nil { return err } - s.RequiredArrayIntegerUnixMinusSeconds = append(s.RequiredArrayIntegerUnixMinusSeconds, elem) + s.RequiredArrayIntegerUnixMinusMicro = append(s.RequiredArrayIntegerUnixMinusMicro, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"required_array_integer_unix-seconds\"") + return errors.Wrap(err, "decode field \"required_array_integer_unix-micro\"") } - case "required_array_null": + case "required_array_integer_unix-milli": requiredBitSet[1] |= 1 << 3 if err := func() error { - s.RequiredArrayNull = make([]struct{}, 0) + s.RequiredArrayIntegerUnixMinusMilli = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem time.Time + v, err := json.DecodeUnixMilli(d) + elem = v + if err != nil { + return err + } + s.RequiredArrayIntegerUnixMinusMilli = append(s.RequiredArrayIntegerUnixMinusMilli, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_unix-milli\"") + } + case "required_array_integer_unix-nano": + requiredBitSet[1] |= 1 << 4 + if err := func() error { + s.RequiredArrayIntegerUnixMinusNano = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem time.Time + v, err := json.DecodeUnixNano(d) + elem = v + if err != nil { + return err + } + s.RequiredArrayIntegerUnixMinusNano = append(s.RequiredArrayIntegerUnixMinusNano, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_unix-nano\"") + } + case "required_array_integer_unix-seconds": + requiredBitSet[1] |= 1 << 5 + if err := func() error { + s.RequiredArrayIntegerUnixMinusSeconds = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem time.Time + v, err := json.DecodeUnixSeconds(d) + elem = v + if err != nil { + return err + } + s.RequiredArrayIntegerUnixMinusSeconds = append(s.RequiredArrayIntegerUnixMinusSeconds, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_unix-seconds\"") + } + case "required_array_null": + requiredBitSet[1] |= 1 << 6 + if err := func() error { + s.RequiredArrayNull = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem struct{} if err := d.Null(); err != nil { @@ -6354,7 +6999,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_null\"") } case "required_array_number": - requiredBitSet[1] |= 1 << 4 + requiredBitSet[1] |= 1 << 7 if err := func() error { s.RequiredArrayNumber = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6374,7 +7019,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number\"") } case "required_array_number_double": - requiredBitSet[1] |= 1 << 5 + requiredBitSet[2] |= 1 << 0 if err := func() error { s.RequiredArrayNumberDouble = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6394,7 +7039,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_double\"") } case "required_array_number_float": - requiredBitSet[1] |= 1 << 6 + requiredBitSet[2] |= 1 << 1 if err := func() error { s.RequiredArrayNumberFloat = make([]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6414,7 +7059,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_float\"") } case "required_array_number_int32": - requiredBitSet[1] |= 1 << 7 + requiredBitSet[2] |= 1 << 2 if err := func() error { s.RequiredArrayNumberInt32 = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6434,7 +7079,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_int32\"") } case "required_array_number_int64": - requiredBitSet[2] |= 1 << 0 + requiredBitSet[2] |= 1 << 3 if err := func() error { s.RequiredArrayNumberInt64 = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6454,7 +7099,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_int64\"") } case "required_array_string": - requiredBitSet[2] |= 1 << 1 + requiredBitSet[2] |= 1 << 4 if err := func() error { s.RequiredArrayString = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6474,7 +7119,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string\"") } case "required_array_string_binary": - requiredBitSet[2] |= 1 << 2 + requiredBitSet[2] |= 1 << 5 if err := func() error { s.RequiredArrayStringBinary = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6494,7 +7139,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_binary\"") } case "required_array_string_byte": - requiredBitSet[2] |= 1 << 3 + requiredBitSet[2] |= 1 << 6 if err := func() error { s.RequiredArrayStringByte = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6514,7 +7159,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_byte\"") } case "required_array_string_date": - requiredBitSet[2] |= 1 << 4 + requiredBitSet[2] |= 1 << 7 if err := func() error { s.RequiredArrayStringDate = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6534,7 +7179,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_date\"") } case "required_array_string_date-time": - requiredBitSet[2] |= 1 << 5 + requiredBitSet[3] |= 1 << 0 if err := func() error { s.RequiredArrayStringDateMinusTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6554,7 +7199,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_date-time\"") } case "required_array_string_duration": - requiredBitSet[2] |= 1 << 6 + requiredBitSet[3] |= 1 << 1 if err := func() error { s.RequiredArrayStringDuration = make([]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6574,7 +7219,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_duration\"") } case "required_array_string_email": - requiredBitSet[2] |= 1 << 7 + requiredBitSet[3] |= 1 << 2 if err := func() error { s.RequiredArrayStringEmail = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6594,7 +7239,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_email\"") } case "required_array_string_hostname": - requiredBitSet[3] |= 1 << 0 + requiredBitSet[3] |= 1 << 3 if err := func() error { s.RequiredArrayStringHostname = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6614,7 +7259,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_hostname\"") } case "required_array_string_int32": - requiredBitSet[3] |= 1 << 1 + requiredBitSet[3] |= 1 << 4 if err := func() error { s.RequiredArrayStringInt32 = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6634,7 +7279,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_int32\"") } case "required_array_string_int64": - requiredBitSet[3] |= 1 << 2 + requiredBitSet[3] |= 1 << 5 if err := func() error { s.RequiredArrayStringInt64 = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6654,7 +7299,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_int64\"") } case "required_array_string_ip": - requiredBitSet[3] |= 1 << 3 + requiredBitSet[3] |= 1 << 6 if err := func() error { s.RequiredArrayStringIP = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6674,7 +7319,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ip\"") } case "required_array_string_ipv4": - requiredBitSet[3] |= 1 << 4 + requiredBitSet[3] |= 1 << 7 if err := func() error { s.RequiredArrayStringIpv4 = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6694,7 +7339,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ipv4\"") } case "required_array_string_ipv6": - requiredBitSet[3] |= 1 << 5 + requiredBitSet[4] |= 1 << 0 if err := func() error { s.RequiredArrayStringIpv6 = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6714,7 +7359,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ipv6\"") } case "required_array_string_password": - requiredBitSet[3] |= 1 << 6 + requiredBitSet[4] |= 1 << 1 if err := func() error { s.RequiredArrayStringPassword = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6734,7 +7379,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_password\"") } case "required_array_string_time": - requiredBitSet[3] |= 1 << 7 + requiredBitSet[4] |= 1 << 2 if err := func() error { s.RequiredArrayStringTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6754,7 +7399,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_time\"") } case "required_array_string_unix": - requiredBitSet[4] |= 1 << 0 + requiredBitSet[4] |= 1 << 3 if err := func() error { s.RequiredArrayStringUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6774,7 +7419,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix\"") } case "required_array_string_unix-micro": - requiredBitSet[4] |= 1 << 1 + requiredBitSet[4] |= 1 << 4 if err := func() error { s.RequiredArrayStringUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6794,7 +7439,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-micro\"") } case "required_array_string_unix-milli": - requiredBitSet[4] |= 1 << 2 + requiredBitSet[4] |= 1 << 5 if err := func() error { s.RequiredArrayStringUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6814,7 +7459,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-milli\"") } case "required_array_string_unix-nano": - requiredBitSet[4] |= 1 << 3 + requiredBitSet[4] |= 1 << 6 if err := func() error { s.RequiredArrayStringUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6834,7 +7479,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-nano\"") } case "required_array_string_unix-seconds": - requiredBitSet[4] |= 1 << 4 + requiredBitSet[4] |= 1 << 7 if err := func() error { s.RequiredArrayStringUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6854,7 +7499,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-seconds\"") } case "required_array_string_uri": - requiredBitSet[4] |= 1 << 5 + requiredBitSet[5] |= 1 << 0 if err := func() error { s.RequiredArrayStringURI = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6874,7 +7519,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uri\"") } case "required_array_string_uuid": - requiredBitSet[4] |= 1 << 6 + requiredBitSet[5] |= 1 << 1 if err := func() error { s.RequiredArrayStringUUID = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6894,7 +7539,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uuid\"") } case "required_boolean": - requiredBitSet[4] |= 1 << 7 + requiredBitSet[5] |= 1 << 2 if err := func() error { v, err := d.Bool() s.RequiredBoolean = bool(v) @@ -6906,7 +7551,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_boolean\"") } case "required_double_array_any": - requiredBitSet[5] |= 1 << 0 + requiredBitSet[5] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayAny = make([][]jx.Raw, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6934,7 +7579,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_any\"") } case "required_double_array_boolean": - requiredBitSet[5] |= 1 << 1 + requiredBitSet[5] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayBoolean = make([][]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6962,7 +7607,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_boolean\"") } case "required_double_array_integer": - requiredBitSet[5] |= 1 << 2 + requiredBitSet[5] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayInteger = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -6990,7 +7635,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer\"") } case "required_double_array_integer_int32": - requiredBitSet[5] |= 1 << 3 + requiredBitSet[5] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7018,7 +7663,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int32\"") } case "required_double_array_integer_int64": - requiredBitSet[5] |= 1 << 4 + requiredBitSet[5] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7045,8 +7690,92 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_double_array_integer_int64\"") } + case "required_double_array_integer_uint": + requiredBitSet[6] |= 1 << 0 + if err := func() error { + s.RequiredDoubleArrayIntegerUint = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint = append(s.RequiredDoubleArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint\"") + } + case "required_double_array_integer_uint32": + requiredBitSet[6] |= 1 << 1 + if err := func() error { + s.RequiredDoubleArrayIntegerUint32 = make([][]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint32 + elem = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint32 = append(s.RequiredDoubleArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint32\"") + } + case "required_double_array_integer_uint64": + requiredBitSet[6] |= 1 << 2 + if err := func() error { + s.RequiredDoubleArrayIntegerUint64 = make([][]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint64 + elem = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint64 = append(s.RequiredDoubleArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint64\"") + } case "required_double_array_integer_unix": - requiredBitSet[5] |= 1 << 5 + requiredBitSet[6] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7074,7 +7803,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix\"") } case "required_double_array_integer_unix-micro": - requiredBitSet[5] |= 1 << 6 + requiredBitSet[6] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7102,7 +7831,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-micro\"") } case "required_double_array_integer_unix-milli": - requiredBitSet[5] |= 1 << 7 + requiredBitSet[6] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7130,7 +7859,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-milli\"") } case "required_double_array_integer_unix-nano": - requiredBitSet[6] |= 1 << 0 + requiredBitSet[6] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7158,7 +7887,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-nano\"") } case "required_double_array_integer_unix-seconds": - requiredBitSet[6] |= 1 << 1 + requiredBitSet[6] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7186,7 +7915,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-seconds\"") } case "required_double_array_null": - requiredBitSet[6] |= 1 << 2 + requiredBitSet[7] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayNull = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7212,7 +7941,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_null\"") } case "required_double_array_number": - requiredBitSet[6] |= 1 << 3 + requiredBitSet[7] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayNumber = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7240,7 +7969,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number\"") } case "required_double_array_number_double": - requiredBitSet[6] |= 1 << 4 + requiredBitSet[7] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayNumberDouble = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7268,7 +7997,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_double\"") } case "required_double_array_number_float": - requiredBitSet[6] |= 1 << 5 + requiredBitSet[7] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayNumberFloat = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7296,7 +8025,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_float\"") } case "required_double_array_number_int32": - requiredBitSet[6] |= 1 << 6 + requiredBitSet[7] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayNumberInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7324,7 +8053,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_int32\"") } case "required_double_array_number_int64": - requiredBitSet[6] |= 1 << 7 + requiredBitSet[7] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayNumberInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7352,7 +8081,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_int64\"") } case "required_double_array_string": - requiredBitSet[7] |= 1 << 0 + requiredBitSet[7] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayString = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7380,7 +8109,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string\"") } case "required_double_array_string_binary": - requiredBitSet[7] |= 1 << 1 + requiredBitSet[7] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringBinary = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7408,7 +8137,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_binary\"") } case "required_double_array_string_byte": - requiredBitSet[7] |= 1 << 2 + requiredBitSet[8] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringByte = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7436,7 +8165,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_byte\"") } case "required_double_array_string_date": - requiredBitSet[7] |= 1 << 3 + requiredBitSet[8] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringDate = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7464,7 +8193,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_date\"") } case "required_double_array_string_date-time": - requiredBitSet[7] |= 1 << 4 + requiredBitSet[8] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringDateMinusTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7492,7 +8221,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_date-time\"") } case "required_double_array_string_duration": - requiredBitSet[7] |= 1 << 5 + requiredBitSet[8] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringDuration = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7520,7 +8249,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_duration\"") } case "required_double_array_string_email": - requiredBitSet[7] |= 1 << 6 + requiredBitSet[8] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringEmail = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7548,7 +8277,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_email\"") } case "required_double_array_string_hostname": - requiredBitSet[7] |= 1 << 7 + requiredBitSet[8] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringHostname = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7576,7 +8305,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_hostname\"") } case "required_double_array_string_int32": - requiredBitSet[8] |= 1 << 0 + requiredBitSet[8] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7604,7 +8333,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int32\"") } case "required_double_array_string_int64": - requiredBitSet[8] |= 1 << 1 + requiredBitSet[8] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7632,7 +8361,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int64\"") } case "required_double_array_string_ip": - requiredBitSet[8] |= 1 << 2 + requiredBitSet[9] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringIP = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7660,7 +8389,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ip\"") } case "required_double_array_string_ipv4": - requiredBitSet[8] |= 1 << 3 + requiredBitSet[9] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringIpv4 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7688,7 +8417,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ipv4\"") } case "required_double_array_string_ipv6": - requiredBitSet[8] |= 1 << 4 + requiredBitSet[9] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringIpv6 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7716,7 +8445,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ipv6\"") } case "required_double_array_string_password": - requiredBitSet[8] |= 1 << 5 + requiredBitSet[9] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringPassword = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7744,7 +8473,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_password\"") } case "required_double_array_string_time": - requiredBitSet[8] |= 1 << 6 + requiredBitSet[9] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7772,7 +8501,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_time\"") } case "required_double_array_string_unix": - requiredBitSet[8] |= 1 << 7 + requiredBitSet[9] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7800,7 +8529,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix\"") } case "required_double_array_string_unix-micro": - requiredBitSet[9] |= 1 << 0 + requiredBitSet[9] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7828,7 +8557,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-micro\"") } case "required_double_array_string_unix-milli": - requiredBitSet[9] |= 1 << 1 + requiredBitSet[9] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7856,7 +8585,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-milli\"") } case "required_double_array_string_unix-nano": - requiredBitSet[9] |= 1 << 2 + requiredBitSet[10] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7884,7 +8613,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-nano\"") } case "required_double_array_string_unix-seconds": - requiredBitSet[9] |= 1 << 3 + requiredBitSet[10] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7912,7 +8641,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-seconds\"") } case "required_double_array_string_uri": - requiredBitSet[9] |= 1 << 4 + requiredBitSet[10] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringURI = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7940,7 +8669,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uri\"") } case "required_double_array_string_uuid": - requiredBitSet[9] |= 1 << 5 + requiredBitSet[10] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUUID = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -7968,7 +8697,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uuid\"") } case "required_integer": - requiredBitSet[9] |= 1 << 6 + requiredBitSet[10] |= 1 << 4 if err := func() error { v, err := d.Int() s.RequiredInteger = int(v) @@ -7980,7 +8709,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer\"") } case "required_integer_int32": - requiredBitSet[9] |= 1 << 7 + requiredBitSet[10] |= 1 << 5 if err := func() error { v, err := d.Int32() s.RequiredIntegerInt32 = int32(v) @@ -7992,7 +8721,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int32\"") } case "required_integer_int64": - requiredBitSet[10] |= 1 << 0 + requiredBitSet[10] |= 1 << 6 if err := func() error { v, err := d.Int64() s.RequiredIntegerInt64 = int64(v) @@ -8003,8 +8732,44 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_integer_int64\"") } + case "required_integer_uint": + requiredBitSet[10] |= 1 << 7 + if err := func() error { + v, err := d.UInt() + s.RequiredIntegerUint = uint(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint\"") + } + case "required_integer_uint32": + requiredBitSet[11] |= 1 << 0 + if err := func() error { + v, err := d.UInt32() + s.RequiredIntegerUint32 = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint32\"") + } + case "required_integer_uint64": + requiredBitSet[11] |= 1 << 1 + if err := func() error { + v, err := d.UInt64() + s.RequiredIntegerUint64 = uint64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint64\"") + } case "required_integer_unix": - requiredBitSet[10] |= 1 << 1 + requiredBitSet[11] |= 1 << 2 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnix = v @@ -8016,7 +8781,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix\"") } case "required_integer_unix-micro": - requiredBitSet[10] |= 1 << 2 + requiredBitSet[11] |= 1 << 3 if err := func() error { v, err := json.DecodeUnixMicro(d) s.RequiredIntegerUnixMinusMicro = v @@ -8028,7 +8793,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-micro\"") } case "required_integer_unix-milli": - requiredBitSet[10] |= 1 << 3 + requiredBitSet[11] |= 1 << 4 if err := func() error { v, err := json.DecodeUnixMilli(d) s.RequiredIntegerUnixMinusMilli = v @@ -8040,7 +8805,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-milli\"") } case "required_integer_unix-nano": - requiredBitSet[10] |= 1 << 4 + requiredBitSet[11] |= 1 << 5 if err := func() error { v, err := json.DecodeUnixNano(d) s.RequiredIntegerUnixMinusNano = v @@ -8052,7 +8817,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-nano\"") } case "required_integer_unix-seconds": - requiredBitSet[10] |= 1 << 5 + requiredBitSet[11] |= 1 << 6 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnixMinusSeconds = v @@ -8064,7 +8829,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-seconds\"") } case "required_null": - requiredBitSet[10] |= 1 << 6 + requiredBitSet[11] |= 1 << 7 if err := func() error { if err := d.Null(); err != nil { return err @@ -8074,7 +8839,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_null\"") } case "required_number": - requiredBitSet[10] |= 1 << 7 + requiredBitSet[12] |= 1 << 0 if err := func() error { v, err := d.Float64() s.RequiredNumber = float64(v) @@ -8086,7 +8851,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number\"") } case "required_number_double": - requiredBitSet[11] |= 1 << 0 + requiredBitSet[12] |= 1 << 1 if err := func() error { v, err := d.Float64() s.RequiredNumberDouble = float64(v) @@ -8098,7 +8863,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_double\"") } case "required_number_float": - requiredBitSet[11] |= 1 << 1 + requiredBitSet[12] |= 1 << 2 if err := func() error { v, err := d.Float32() s.RequiredNumberFloat = float32(v) @@ -8110,7 +8875,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_float\"") } case "required_number_int32": - requiredBitSet[11] |= 1 << 2 + requiredBitSet[12] |= 1 << 3 if err := func() error { v, err := d.Int32() s.RequiredNumberInt32 = int32(v) @@ -8122,7 +8887,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int32\"") } case "required_number_int64": - requiredBitSet[11] |= 1 << 3 + requiredBitSet[12] |= 1 << 4 if err := func() error { v, err := d.Int64() s.RequiredNumberInt64 = int64(v) @@ -8134,7 +8899,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int64\"") } case "required_string": - requiredBitSet[11] |= 1 << 4 + requiredBitSet[12] |= 1 << 5 if err := func() error { v, err := d.Str() s.RequiredString = string(v) @@ -8146,7 +8911,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string\"") } case "required_string_binary": - requiredBitSet[11] |= 1 << 5 + requiredBitSet[12] |= 1 << 6 if err := func() error { v, err := d.Str() s.RequiredStringBinary = string(v) @@ -8158,7 +8923,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_binary\"") } case "required_string_byte": - requiredBitSet[11] |= 1 << 6 + requiredBitSet[12] |= 1 << 7 if err := func() error { v, err := d.Base64() s.RequiredStringByte = []byte(v) @@ -8170,7 +8935,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_byte\"") } case "required_string_date": - requiredBitSet[11] |= 1 << 7 + requiredBitSet[13] |= 1 << 0 if err := func() error { v, err := json.DecodeDate(d) s.RequiredStringDate = v @@ -8182,7 +8947,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date\"") } case "required_string_date-time": - requiredBitSet[12] |= 1 << 0 + requiredBitSet[13] |= 1 << 1 if err := func() error { v, err := json.DecodeDateTime(d) s.RequiredStringDateMinusTime = v @@ -8194,7 +8959,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date-time\"") } case "required_string_duration": - requiredBitSet[12] |= 1 << 1 + requiredBitSet[13] |= 1 << 2 if err := func() error { v, err := json.DecodeDuration(d) s.RequiredStringDuration = v @@ -8206,7 +8971,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_duration\"") } case "required_string_email": - requiredBitSet[12] |= 1 << 2 + requiredBitSet[13] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringEmail = string(v) @@ -8218,7 +8983,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_email\"") } case "required_string_hostname": - requiredBitSet[12] |= 1 << 3 + requiredBitSet[13] |= 1 << 4 if err := func() error { v, err := d.Str() s.RequiredStringHostname = string(v) @@ -8230,7 +8995,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_hostname\"") } case "required_string_int32": - requiredBitSet[12] |= 1 << 4 + requiredBitSet[13] |= 1 << 5 if err := func() error { v, err := json.DecodeStringInt32(d) s.RequiredStringInt32 = v @@ -8242,7 +9007,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int32\"") } case "required_string_int64": - requiredBitSet[12] |= 1 << 5 + requiredBitSet[13] |= 1 << 6 if err := func() error { v, err := json.DecodeStringInt64(d) s.RequiredStringInt64 = v @@ -8254,7 +9019,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int64\"") } case "required_string_ip": - requiredBitSet[12] |= 1 << 6 + requiredBitSet[13] |= 1 << 7 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIP = v @@ -8266,7 +9031,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ip\"") } case "required_string_ipv4": - requiredBitSet[12] |= 1 << 7 + requiredBitSet[14] |= 1 << 0 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIpv4 = v @@ -8278,7 +9043,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv4\"") } case "required_string_ipv6": - requiredBitSet[13] |= 1 << 0 + requiredBitSet[14] |= 1 << 1 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIpv6 = v @@ -8290,7 +9055,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv6\"") } case "required_string_password": - requiredBitSet[13] |= 1 << 1 + requiredBitSet[14] |= 1 << 2 if err := func() error { v, err := d.Str() s.RequiredStringPassword = string(v) @@ -8302,7 +9067,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_password\"") } case "required_string_time": - requiredBitSet[13] |= 1 << 2 + requiredBitSet[14] |= 1 << 3 if err := func() error { v, err := json.DecodeTime(d) s.RequiredStringTime = v @@ -8314,7 +9079,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_time\"") } case "required_string_unix": - requiredBitSet[13] |= 1 << 3 + requiredBitSet[14] |= 1 << 4 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnix = v @@ -8326,7 +9091,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix\"") } case "required_string_unix-micro": - requiredBitSet[13] |= 1 << 4 + requiredBitSet[14] |= 1 << 5 if err := func() error { v, err := json.DecodeStringUnixMicro(d) s.RequiredStringUnixMinusMicro = v @@ -8338,7 +9103,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-micro\"") } case "required_string_unix-milli": - requiredBitSet[13] |= 1 << 5 + requiredBitSet[14] |= 1 << 6 if err := func() error { v, err := json.DecodeStringUnixMilli(d) s.RequiredStringUnixMinusMilli = v @@ -8350,7 +9115,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-milli\"") } case "required_string_unix-nano": - requiredBitSet[13] |= 1 << 6 + requiredBitSet[14] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUnixNano(d) s.RequiredStringUnixMinusNano = v @@ -8362,7 +9127,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-nano\"") } case "required_string_unix-seconds": - requiredBitSet[13] |= 1 << 7 + requiredBitSet[15] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnixMinusSeconds = v @@ -8374,7 +9139,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-seconds\"") } case "required_string_uri": - requiredBitSet[14] |= 1 << 0 + requiredBitSet[15] |= 1 << 1 if err := func() error { v, err := json.DecodeURI(d) s.RequiredStringURI = v @@ -8386,7 +9151,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uri\"") } case "required_string_uuid": - requiredBitSet[14] |= 1 << 1 + requiredBitSet[15] |= 1 << 2 if err := func() error { v, err := json.DecodeUUID(d) s.RequiredStringUUID = v @@ -8503,6 +9268,63 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_array_integer_int64\"") } + case "optional_array_integer_uint": + if err := func() error { + s.OptionalArrayIntegerUint = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint = append(s.OptionalArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint\"") + } + case "optional_array_integer_uint32": + if err := func() error { + s.OptionalArrayIntegerUint32 = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint32 = append(s.OptionalArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint32\"") + } + case "optional_array_integer_uint64": + if err := func() error { + s.OptionalArrayIntegerUint64 = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint64 = append(s.OptionalArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint64\"") + } case "optional_array_integer_unix": if err := func() error { s.OptionalArrayIntegerUnix = make([]time.Time, 0) @@ -9273,6 +10095,87 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_double_array_integer_int64\"") } + case "optional_double_array_integer_uint": + if err := func() error { + s.OptionalDoubleArrayIntegerUint = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint = append(s.OptionalDoubleArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint\"") + } + case "optional_double_array_integer_uint32": + if err := func() error { + s.OptionalDoubleArrayIntegerUint32 = make([][]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint32 + elem = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint32 = append(s.OptionalDoubleArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint32\"") + } + case "optional_double_array_integer_uint64": + if err := func() error { + s.OptionalDoubleArrayIntegerUint64 = make([][]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint64 + elem = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint64 = append(s.OptionalDoubleArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint64\"") + } case "optional_double_array_integer_unix": if err := func() error { s.OptionalDoubleArrayIntegerUnix = make([][]time.Time, 0) @@ -10192,6 +11095,36 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_integer_int64\"") } + case "optional_integer_uint": + if err := func() error { + s.OptionalIntegerUint.Reset() + if err := s.OptionalIntegerUint.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint\"") + } + case "optional_integer_uint32": + if err := func() error { + s.OptionalIntegerUint32.Reset() + if err := s.OptionalIntegerUint32.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint32\"") + } + case "optional_integer_uint64": + if err := func() error { + s.OptionalIntegerUint64.Reset() + if err := s.OptionalIntegerUint64.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint64\"") + } case "optional_integer_unix": if err := func() error { s.OptionalIntegerUnix.Reset() @@ -10532,7 +11465,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [29]uint8{ + for i, mask := range [31]uint8{ 0b11111111, 0b11111111, 0b11111111, @@ -10547,7 +11480,9 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { 0b11111111, 0b11111111, 0b11111111, - 0b00000011, + 0b11111111, + 0b00000111, + 0b00000000, 0b00000000, 0b00000000, 0b00000000, @@ -10715,6 +11650,33 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + + e.FieldStart("required_array_integer_uint") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint { + e.UInt(elem) + } + e.ArrEnd() + } + { + + e.FieldStart("required_array_integer_uint32") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint32 { + e.UInt32(elem) + } + e.ArrEnd() + } + { + + e.FieldStart("required_array_integer_uint64") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint64 { + e.UInt64(elem) + } + e.ArrEnd() + } { e.FieldStart("required_array_integer_unix") @@ -11085,6 +12047,45 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + + e.FieldStart("required_double_array_integer_uint") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerUint { + e.ArrStart() + for _, elem := range elem { + e.UInt(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + { + + e.FieldStart("required_double_array_integer_uint32") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerUint32 { + e.ArrStart() + for _, elem := range elem { + e.UInt32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + { + + e.FieldStart("required_double_array_integer_uint64") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerUint64 { + e.ArrStart() + for _, elem := range elem { + e.UInt64(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } { e.FieldStart("required_double_array_integer_unix") @@ -11530,6 +12531,21 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { e.FieldStart("required_integer_int64") e.Int64(s.RequiredIntegerInt64) } + { + + e.FieldStart("required_integer_uint") + e.UInt(s.RequiredIntegerUint) + } + { + + e.FieldStart("required_integer_uint32") + e.UInt32(s.RequiredIntegerUint32) + } + { + + e.FieldStart("required_integer_uint64") + e.UInt64(s.RequiredIntegerUint64) + } { e.FieldStart("required_integer_unix") @@ -11755,6 +12771,36 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalArrayIntegerUint != nil { + e.FieldStart("optional_array_integer_uint") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint { + e.UInt(elem) + } + e.ArrEnd() + } + } + { + if s.OptionalArrayIntegerUint32 != nil { + e.FieldStart("optional_array_integer_uint32") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint32 { + e.UInt32(elem) + } + e.ArrEnd() + } + } + { + if s.OptionalArrayIntegerUint64 != nil { + e.FieldStart("optional_array_integer_uint64") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint64 { + e.UInt64(elem) + } + e.ArrEnd() + } + } { if s.OptionalArrayIntegerUnix != nil { e.FieldStart("optional_array_integer_unix") @@ -12129,7 +13175,49 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { for _, elem := range s.OptionalDoubleArrayInteger { e.ArrStart() for _, elem := range elem { - e.Int(elem) + e.Int(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + { + if s.OptionalDoubleArrayIntegerInt32 != nil { + e.FieldStart("optional_double_array_integer_int32") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerInt32 { + e.ArrStart() + for _, elem := range elem { + e.Int32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + { + if s.OptionalDoubleArrayIntegerInt64 != nil { + e.FieldStart("optional_double_array_integer_int64") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerInt64 { + e.ArrStart() + for _, elem := range elem { + e.Int64(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + { + if s.OptionalDoubleArrayIntegerUint != nil { + e.FieldStart("optional_double_array_integer_uint") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerUint { + e.ArrStart() + for _, elem := range elem { + e.UInt(elem) } e.ArrEnd() } @@ -12137,13 +13225,13 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } } { - if s.OptionalDoubleArrayIntegerInt32 != nil { - e.FieldStart("optional_double_array_integer_int32") + if s.OptionalDoubleArrayIntegerUint32 != nil { + e.FieldStart("optional_double_array_integer_uint32") e.ArrStart() - for _, elem := range s.OptionalDoubleArrayIntegerInt32 { + for _, elem := range s.OptionalDoubleArrayIntegerUint32 { e.ArrStart() for _, elem := range elem { - e.Int32(elem) + e.UInt32(elem) } e.ArrEnd() } @@ -12151,13 +13239,13 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } } { - if s.OptionalDoubleArrayIntegerInt64 != nil { - e.FieldStart("optional_double_array_integer_int64") + if s.OptionalDoubleArrayIntegerUint64 != nil { + e.FieldStart("optional_double_array_integer_uint64") e.ArrStart() - for _, elem := range s.OptionalDoubleArrayIntegerInt64 { + for _, elem := range s.OptionalDoubleArrayIntegerUint64 { e.ArrStart() for _, elem := range elem { - e.Int64(elem) + e.UInt64(elem) } e.ArrEnd() } @@ -12645,6 +13733,24 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { s.OptionalIntegerInt64.Encode(e) } } + { + if s.OptionalIntegerUint.Set { + e.FieldStart("optional_integer_uint") + s.OptionalIntegerUint.Encode(e) + } + } + { + if s.OptionalIntegerUint32.Set { + e.FieldStart("optional_integer_uint32") + s.OptionalIntegerUint32.Encode(e) + } + } + { + if s.OptionalIntegerUint64.Set { + e.FieldStart("optional_integer_uint64") + s.OptionalIntegerUint64.Encode(e) + } + } { if s.OptionalIntegerUnix.Set { e.FieldStart("optional_integer_unix") @@ -12844,235 +13950,253 @@ func (s TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfTestRequestRequiredFormatTestReq = [228]string{ +var jsonFieldsNameOfTestRequestRequiredFormatTestReq = [246]string{ 0: "required_any", 1: "required_array_any", 2: "required_array_boolean", 3: "required_array_integer", 4: "required_array_integer_int32", 5: "required_array_integer_int64", - 6: "required_array_integer_unix", - 7: "required_array_integer_unix-micro", - 8: "required_array_integer_unix-milli", - 9: "required_array_integer_unix-nano", - 10: "required_array_integer_unix-seconds", - 11: "required_array_null", - 12: "required_array_number", - 13: "required_array_number_double", - 14: "required_array_number_float", - 15: "required_array_number_int32", - 16: "required_array_number_int64", - 17: "required_array_string", - 18: "required_array_string_binary", - 19: "required_array_string_byte", - 20: "required_array_string_date", - 21: "required_array_string_date-time", - 22: "required_array_string_duration", - 23: "required_array_string_email", - 24: "required_array_string_hostname", - 25: "required_array_string_int32", - 26: "required_array_string_int64", - 27: "required_array_string_ip", - 28: "required_array_string_ipv4", - 29: "required_array_string_ipv6", - 30: "required_array_string_password", - 31: "required_array_string_time", - 32: "required_array_string_unix", - 33: "required_array_string_unix-micro", - 34: "required_array_string_unix-milli", - 35: "required_array_string_unix-nano", - 36: "required_array_string_unix-seconds", - 37: "required_array_string_uri", - 38: "required_array_string_uuid", - 39: "required_boolean", - 40: "required_double_array_any", - 41: "required_double_array_boolean", - 42: "required_double_array_integer", - 43: "required_double_array_integer_int32", - 44: "required_double_array_integer_int64", - 45: "required_double_array_integer_unix", - 46: "required_double_array_integer_unix-micro", - 47: "required_double_array_integer_unix-milli", - 48: "required_double_array_integer_unix-nano", - 49: "required_double_array_integer_unix-seconds", - 50: "required_double_array_null", - 51: "required_double_array_number", - 52: "required_double_array_number_double", - 53: "required_double_array_number_float", - 54: "required_double_array_number_int32", - 55: "required_double_array_number_int64", - 56: "required_double_array_string", - 57: "required_double_array_string_binary", - 58: "required_double_array_string_byte", - 59: "required_double_array_string_date", - 60: "required_double_array_string_date-time", - 61: "required_double_array_string_duration", - 62: "required_double_array_string_email", - 63: "required_double_array_string_hostname", - 64: "required_double_array_string_int32", - 65: "required_double_array_string_int64", - 66: "required_double_array_string_ip", - 67: "required_double_array_string_ipv4", - 68: "required_double_array_string_ipv6", - 69: "required_double_array_string_password", - 70: "required_double_array_string_time", - 71: "required_double_array_string_unix", - 72: "required_double_array_string_unix-micro", - 73: "required_double_array_string_unix-milli", - 74: "required_double_array_string_unix-nano", - 75: "required_double_array_string_unix-seconds", - 76: "required_double_array_string_uri", - 77: "required_double_array_string_uuid", - 78: "required_integer", - 79: "required_integer_int32", - 80: "required_integer_int64", - 81: "required_integer_unix", - 82: "required_integer_unix-micro", - 83: "required_integer_unix-milli", - 84: "required_integer_unix-nano", - 85: "required_integer_unix-seconds", - 86: "required_null", - 87: "required_number", - 88: "required_number_double", - 89: "required_number_float", - 90: "required_number_int32", - 91: "required_number_int64", - 92: "required_string", - 93: "required_string_binary", - 94: "required_string_byte", - 95: "required_string_date", - 96: "required_string_date-time", - 97: "required_string_duration", - 98: "required_string_email", - 99: "required_string_hostname", - 100: "required_string_int32", - 101: "required_string_int64", - 102: "required_string_ip", - 103: "required_string_ipv4", - 104: "required_string_ipv6", - 105: "required_string_password", - 106: "required_string_time", - 107: "required_string_unix", - 108: "required_string_unix-micro", - 109: "required_string_unix-milli", - 110: "required_string_unix-nano", - 111: "required_string_unix-seconds", - 112: "required_string_uri", - 113: "required_string_uuid", - 114: "optional_any", - 115: "optional_array_any", - 116: "optional_array_boolean", - 117: "optional_array_integer", - 118: "optional_array_integer_int32", - 119: "optional_array_integer_int64", - 120: "optional_array_integer_unix", - 121: "optional_array_integer_unix-micro", - 122: "optional_array_integer_unix-milli", - 123: "optional_array_integer_unix-nano", - 124: "optional_array_integer_unix-seconds", - 125: "optional_array_null", - 126: "optional_array_number", - 127: "optional_array_number_double", - 128: "optional_array_number_float", - 129: "optional_array_number_int32", - 130: "optional_array_number_int64", - 131: "optional_array_string", - 132: "optional_array_string_binary", - 133: "optional_array_string_byte", - 134: "optional_array_string_date", - 135: "optional_array_string_date-time", - 136: "optional_array_string_duration", - 137: "optional_array_string_email", - 138: "optional_array_string_hostname", - 139: "optional_array_string_int32", - 140: "optional_array_string_int64", - 141: "optional_array_string_ip", - 142: "optional_array_string_ipv4", - 143: "optional_array_string_ipv6", - 144: "optional_array_string_password", - 145: "optional_array_string_time", - 146: "optional_array_string_unix", - 147: "optional_array_string_unix-micro", - 148: "optional_array_string_unix-milli", - 149: "optional_array_string_unix-nano", - 150: "optional_array_string_unix-seconds", - 151: "optional_array_string_uri", - 152: "optional_array_string_uuid", - 153: "optional_boolean", - 154: "optional_double_array_any", - 155: "optional_double_array_boolean", - 156: "optional_double_array_integer", - 157: "optional_double_array_integer_int32", - 158: "optional_double_array_integer_int64", - 159: "optional_double_array_integer_unix", - 160: "optional_double_array_integer_unix-micro", - 161: "optional_double_array_integer_unix-milli", - 162: "optional_double_array_integer_unix-nano", - 163: "optional_double_array_integer_unix-seconds", - 164: "optional_double_array_null", - 165: "optional_double_array_number", - 166: "optional_double_array_number_double", - 167: "optional_double_array_number_float", - 168: "optional_double_array_number_int32", - 169: "optional_double_array_number_int64", - 170: "optional_double_array_string", - 171: "optional_double_array_string_binary", - 172: "optional_double_array_string_byte", - 173: "optional_double_array_string_date", - 174: "optional_double_array_string_date-time", - 175: "optional_double_array_string_duration", - 176: "optional_double_array_string_email", - 177: "optional_double_array_string_hostname", - 178: "optional_double_array_string_int32", - 179: "optional_double_array_string_int64", - 180: "optional_double_array_string_ip", - 181: "optional_double_array_string_ipv4", - 182: "optional_double_array_string_ipv6", - 183: "optional_double_array_string_password", - 184: "optional_double_array_string_time", - 185: "optional_double_array_string_unix", - 186: "optional_double_array_string_unix-micro", - 187: "optional_double_array_string_unix-milli", - 188: "optional_double_array_string_unix-nano", - 189: "optional_double_array_string_unix-seconds", - 190: "optional_double_array_string_uri", - 191: "optional_double_array_string_uuid", - 192: "optional_integer", - 193: "optional_integer_int32", - 194: "optional_integer_int64", - 195: "optional_integer_unix", - 196: "optional_integer_unix-micro", - 197: "optional_integer_unix-milli", - 198: "optional_integer_unix-nano", - 199: "optional_integer_unix-seconds", - 200: "optional_null", - 201: "optional_number", - 202: "optional_number_double", - 203: "optional_number_float", - 204: "optional_number_int32", - 205: "optional_number_int64", - 206: "optional_string", - 207: "optional_string_binary", - 208: "optional_string_byte", - 209: "optional_string_date", - 210: "optional_string_date-time", - 211: "optional_string_duration", - 212: "optional_string_email", - 213: "optional_string_hostname", - 214: "optional_string_int32", - 215: "optional_string_int64", - 216: "optional_string_ip", - 217: "optional_string_ipv4", - 218: "optional_string_ipv6", - 219: "optional_string_password", - 220: "optional_string_time", - 221: "optional_string_unix", - 222: "optional_string_unix-micro", - 223: "optional_string_unix-milli", - 224: "optional_string_unix-nano", - 225: "optional_string_unix-seconds", - 226: "optional_string_uri", - 227: "optional_string_uuid", + 6: "required_array_integer_uint", + 7: "required_array_integer_uint32", + 8: "required_array_integer_uint64", + 9: "required_array_integer_unix", + 10: "required_array_integer_unix-micro", + 11: "required_array_integer_unix-milli", + 12: "required_array_integer_unix-nano", + 13: "required_array_integer_unix-seconds", + 14: "required_array_null", + 15: "required_array_number", + 16: "required_array_number_double", + 17: "required_array_number_float", + 18: "required_array_number_int32", + 19: "required_array_number_int64", + 20: "required_array_string", + 21: "required_array_string_binary", + 22: "required_array_string_byte", + 23: "required_array_string_date", + 24: "required_array_string_date-time", + 25: "required_array_string_duration", + 26: "required_array_string_email", + 27: "required_array_string_hostname", + 28: "required_array_string_int32", + 29: "required_array_string_int64", + 30: "required_array_string_ip", + 31: "required_array_string_ipv4", + 32: "required_array_string_ipv6", + 33: "required_array_string_password", + 34: "required_array_string_time", + 35: "required_array_string_unix", + 36: "required_array_string_unix-micro", + 37: "required_array_string_unix-milli", + 38: "required_array_string_unix-nano", + 39: "required_array_string_unix-seconds", + 40: "required_array_string_uri", + 41: "required_array_string_uuid", + 42: "required_boolean", + 43: "required_double_array_any", + 44: "required_double_array_boolean", + 45: "required_double_array_integer", + 46: "required_double_array_integer_int32", + 47: "required_double_array_integer_int64", + 48: "required_double_array_integer_uint", + 49: "required_double_array_integer_uint32", + 50: "required_double_array_integer_uint64", + 51: "required_double_array_integer_unix", + 52: "required_double_array_integer_unix-micro", + 53: "required_double_array_integer_unix-milli", + 54: "required_double_array_integer_unix-nano", + 55: "required_double_array_integer_unix-seconds", + 56: "required_double_array_null", + 57: "required_double_array_number", + 58: "required_double_array_number_double", + 59: "required_double_array_number_float", + 60: "required_double_array_number_int32", + 61: "required_double_array_number_int64", + 62: "required_double_array_string", + 63: "required_double_array_string_binary", + 64: "required_double_array_string_byte", + 65: "required_double_array_string_date", + 66: "required_double_array_string_date-time", + 67: "required_double_array_string_duration", + 68: "required_double_array_string_email", + 69: "required_double_array_string_hostname", + 70: "required_double_array_string_int32", + 71: "required_double_array_string_int64", + 72: "required_double_array_string_ip", + 73: "required_double_array_string_ipv4", + 74: "required_double_array_string_ipv6", + 75: "required_double_array_string_password", + 76: "required_double_array_string_time", + 77: "required_double_array_string_unix", + 78: "required_double_array_string_unix-micro", + 79: "required_double_array_string_unix-milli", + 80: "required_double_array_string_unix-nano", + 81: "required_double_array_string_unix-seconds", + 82: "required_double_array_string_uri", + 83: "required_double_array_string_uuid", + 84: "required_integer", + 85: "required_integer_int32", + 86: "required_integer_int64", + 87: "required_integer_uint", + 88: "required_integer_uint32", + 89: "required_integer_uint64", + 90: "required_integer_unix", + 91: "required_integer_unix-micro", + 92: "required_integer_unix-milli", + 93: "required_integer_unix-nano", + 94: "required_integer_unix-seconds", + 95: "required_null", + 96: "required_number", + 97: "required_number_double", + 98: "required_number_float", + 99: "required_number_int32", + 100: "required_number_int64", + 101: "required_string", + 102: "required_string_binary", + 103: "required_string_byte", + 104: "required_string_date", + 105: "required_string_date-time", + 106: "required_string_duration", + 107: "required_string_email", + 108: "required_string_hostname", + 109: "required_string_int32", + 110: "required_string_int64", + 111: "required_string_ip", + 112: "required_string_ipv4", + 113: "required_string_ipv6", + 114: "required_string_password", + 115: "required_string_time", + 116: "required_string_unix", + 117: "required_string_unix-micro", + 118: "required_string_unix-milli", + 119: "required_string_unix-nano", + 120: "required_string_unix-seconds", + 121: "required_string_uri", + 122: "required_string_uuid", + 123: "optional_any", + 124: "optional_array_any", + 125: "optional_array_boolean", + 126: "optional_array_integer", + 127: "optional_array_integer_int32", + 128: "optional_array_integer_int64", + 129: "optional_array_integer_uint", + 130: "optional_array_integer_uint32", + 131: "optional_array_integer_uint64", + 132: "optional_array_integer_unix", + 133: "optional_array_integer_unix-micro", + 134: "optional_array_integer_unix-milli", + 135: "optional_array_integer_unix-nano", + 136: "optional_array_integer_unix-seconds", + 137: "optional_array_null", + 138: "optional_array_number", + 139: "optional_array_number_double", + 140: "optional_array_number_float", + 141: "optional_array_number_int32", + 142: "optional_array_number_int64", + 143: "optional_array_string", + 144: "optional_array_string_binary", + 145: "optional_array_string_byte", + 146: "optional_array_string_date", + 147: "optional_array_string_date-time", + 148: "optional_array_string_duration", + 149: "optional_array_string_email", + 150: "optional_array_string_hostname", + 151: "optional_array_string_int32", + 152: "optional_array_string_int64", + 153: "optional_array_string_ip", + 154: "optional_array_string_ipv4", + 155: "optional_array_string_ipv6", + 156: "optional_array_string_password", + 157: "optional_array_string_time", + 158: "optional_array_string_unix", + 159: "optional_array_string_unix-micro", + 160: "optional_array_string_unix-milli", + 161: "optional_array_string_unix-nano", + 162: "optional_array_string_unix-seconds", + 163: "optional_array_string_uri", + 164: "optional_array_string_uuid", + 165: "optional_boolean", + 166: "optional_double_array_any", + 167: "optional_double_array_boolean", + 168: "optional_double_array_integer", + 169: "optional_double_array_integer_int32", + 170: "optional_double_array_integer_int64", + 171: "optional_double_array_integer_uint", + 172: "optional_double_array_integer_uint32", + 173: "optional_double_array_integer_uint64", + 174: "optional_double_array_integer_unix", + 175: "optional_double_array_integer_unix-micro", + 176: "optional_double_array_integer_unix-milli", + 177: "optional_double_array_integer_unix-nano", + 178: "optional_double_array_integer_unix-seconds", + 179: "optional_double_array_null", + 180: "optional_double_array_number", + 181: "optional_double_array_number_double", + 182: "optional_double_array_number_float", + 183: "optional_double_array_number_int32", + 184: "optional_double_array_number_int64", + 185: "optional_double_array_string", + 186: "optional_double_array_string_binary", + 187: "optional_double_array_string_byte", + 188: "optional_double_array_string_date", + 189: "optional_double_array_string_date-time", + 190: "optional_double_array_string_duration", + 191: "optional_double_array_string_email", + 192: "optional_double_array_string_hostname", + 193: "optional_double_array_string_int32", + 194: "optional_double_array_string_int64", + 195: "optional_double_array_string_ip", + 196: "optional_double_array_string_ipv4", + 197: "optional_double_array_string_ipv6", + 198: "optional_double_array_string_password", + 199: "optional_double_array_string_time", + 200: "optional_double_array_string_unix", + 201: "optional_double_array_string_unix-micro", + 202: "optional_double_array_string_unix-milli", + 203: "optional_double_array_string_unix-nano", + 204: "optional_double_array_string_unix-seconds", + 205: "optional_double_array_string_uri", + 206: "optional_double_array_string_uuid", + 207: "optional_integer", + 208: "optional_integer_int32", + 209: "optional_integer_int64", + 210: "optional_integer_uint", + 211: "optional_integer_uint32", + 212: "optional_integer_uint64", + 213: "optional_integer_unix", + 214: "optional_integer_unix-micro", + 215: "optional_integer_unix-milli", + 216: "optional_integer_unix-nano", + 217: "optional_integer_unix-seconds", + 218: "optional_null", + 219: "optional_number", + 220: "optional_number_double", + 221: "optional_number_float", + 222: "optional_number_int32", + 223: "optional_number_int64", + 224: "optional_string", + 225: "optional_string_binary", + 226: "optional_string_byte", + 227: "optional_string_date", + 228: "optional_string_date-time", + 229: "optional_string_duration", + 230: "optional_string_email", + 231: "optional_string_hostname", + 232: "optional_string_int32", + 233: "optional_string_int64", + 234: "optional_string_ip", + 235: "optional_string_ipv4", + 236: "optional_string_ipv6", + 237: "optional_string_password", + 238: "optional_string_time", + 239: "optional_string_unix", + 240: "optional_string_unix-micro", + 241: "optional_string_unix-milli", + 242: "optional_string_unix-nano", + 243: "optional_string_unix-seconds", + 244: "optional_string_uri", + 245: "optional_string_uuid", } // Decode decodes TestRequestRequiredFormatTestReq from json. @@ -13080,7 +14204,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode TestRequestRequiredFormatTestReq to nil") } - var requiredBitSet [29]uint8 + var requiredBitSet [31]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -13196,8 +14320,68 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_array_integer_int64\"") } - case "required_array_integer_unix": + case "required_array_integer_uint": requiredBitSet[0] |= 1 << 6 + if err := func() error { + s.RequiredArrayIntegerUint = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + s.RequiredArrayIntegerUint = append(s.RequiredArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_uint\"") + } + case "required_array_integer_uint32": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + s.RequiredArrayIntegerUint32 = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) + if err != nil { + return err + } + s.RequiredArrayIntegerUint32 = append(s.RequiredArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_uint32\"") + } + case "required_array_integer_uint64": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + s.RequiredArrayIntegerUint64 = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) + if err != nil { + return err + } + s.RequiredArrayIntegerUint64 = append(s.RequiredArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_uint64\"") + } + case "required_array_integer_unix": + requiredBitSet[1] |= 1 << 1 if err := func() error { s.RequiredArrayIntegerUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13217,7 +14401,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix\"") } case "required_array_integer_unix-micro": - requiredBitSet[0] |= 1 << 7 + requiredBitSet[1] |= 1 << 2 if err := func() error { s.RequiredArrayIntegerUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13237,7 +14421,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-micro\"") } case "required_array_integer_unix-milli": - requiredBitSet[1] |= 1 << 0 + requiredBitSet[1] |= 1 << 3 if err := func() error { s.RequiredArrayIntegerUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13257,7 +14441,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-milli\"") } case "required_array_integer_unix-nano": - requiredBitSet[1] |= 1 << 1 + requiredBitSet[1] |= 1 << 4 if err := func() error { s.RequiredArrayIntegerUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13277,7 +14461,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-nano\"") } case "required_array_integer_unix-seconds": - requiredBitSet[1] |= 1 << 2 + requiredBitSet[1] |= 1 << 5 if err := func() error { s.RequiredArrayIntegerUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13297,7 +14481,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-seconds\"") } case "required_array_null": - requiredBitSet[1] |= 1 << 3 + requiredBitSet[1] |= 1 << 6 if err := func() error { s.RequiredArrayNull = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13315,7 +14499,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_null\"") } case "required_array_number": - requiredBitSet[1] |= 1 << 4 + requiredBitSet[1] |= 1 << 7 if err := func() error { s.RequiredArrayNumber = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13335,7 +14519,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number\"") } case "required_array_number_double": - requiredBitSet[1] |= 1 << 5 + requiredBitSet[2] |= 1 << 0 if err := func() error { s.RequiredArrayNumberDouble = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13355,7 +14539,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_double\"") } case "required_array_number_float": - requiredBitSet[1] |= 1 << 6 + requiredBitSet[2] |= 1 << 1 if err := func() error { s.RequiredArrayNumberFloat = make([]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13375,7 +14559,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_float\"") } case "required_array_number_int32": - requiredBitSet[1] |= 1 << 7 + requiredBitSet[2] |= 1 << 2 if err := func() error { s.RequiredArrayNumberInt32 = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13395,7 +14579,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_int32\"") } case "required_array_number_int64": - requiredBitSet[2] |= 1 << 0 + requiredBitSet[2] |= 1 << 3 if err := func() error { s.RequiredArrayNumberInt64 = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13415,7 +14599,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_int64\"") } case "required_array_string": - requiredBitSet[2] |= 1 << 1 + requiredBitSet[2] |= 1 << 4 if err := func() error { s.RequiredArrayString = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13435,7 +14619,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string\"") } case "required_array_string_binary": - requiredBitSet[2] |= 1 << 2 + requiredBitSet[2] |= 1 << 5 if err := func() error { s.RequiredArrayStringBinary = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13455,7 +14639,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_binary\"") } case "required_array_string_byte": - requiredBitSet[2] |= 1 << 3 + requiredBitSet[2] |= 1 << 6 if err := func() error { s.RequiredArrayStringByte = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13475,7 +14659,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_byte\"") } case "required_array_string_date": - requiredBitSet[2] |= 1 << 4 + requiredBitSet[2] |= 1 << 7 if err := func() error { s.RequiredArrayStringDate = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13495,7 +14679,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_date\"") } case "required_array_string_date-time": - requiredBitSet[2] |= 1 << 5 + requiredBitSet[3] |= 1 << 0 if err := func() error { s.RequiredArrayStringDateMinusTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13515,7 +14699,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_date-time\"") } case "required_array_string_duration": - requiredBitSet[2] |= 1 << 6 + requiredBitSet[3] |= 1 << 1 if err := func() error { s.RequiredArrayStringDuration = make([]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13535,7 +14719,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_duration\"") } case "required_array_string_email": - requiredBitSet[2] |= 1 << 7 + requiredBitSet[3] |= 1 << 2 if err := func() error { s.RequiredArrayStringEmail = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13555,7 +14739,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_email\"") } case "required_array_string_hostname": - requiredBitSet[3] |= 1 << 0 + requiredBitSet[3] |= 1 << 3 if err := func() error { s.RequiredArrayStringHostname = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13575,7 +14759,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_hostname\"") } case "required_array_string_int32": - requiredBitSet[3] |= 1 << 1 + requiredBitSet[3] |= 1 << 4 if err := func() error { s.RequiredArrayStringInt32 = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13595,7 +14779,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_int32\"") } case "required_array_string_int64": - requiredBitSet[3] |= 1 << 2 + requiredBitSet[3] |= 1 << 5 if err := func() error { s.RequiredArrayStringInt64 = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13615,7 +14799,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_int64\"") } case "required_array_string_ip": - requiredBitSet[3] |= 1 << 3 + requiredBitSet[3] |= 1 << 6 if err := func() error { s.RequiredArrayStringIP = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13635,7 +14819,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ip\"") } case "required_array_string_ipv4": - requiredBitSet[3] |= 1 << 4 + requiredBitSet[3] |= 1 << 7 if err := func() error { s.RequiredArrayStringIpv4 = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13655,7 +14839,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ipv4\"") } case "required_array_string_ipv6": - requiredBitSet[3] |= 1 << 5 + requiredBitSet[4] |= 1 << 0 if err := func() error { s.RequiredArrayStringIpv6 = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13675,7 +14859,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ipv6\"") } case "required_array_string_password": - requiredBitSet[3] |= 1 << 6 + requiredBitSet[4] |= 1 << 1 if err := func() error { s.RequiredArrayStringPassword = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13695,7 +14879,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_password\"") } case "required_array_string_time": - requiredBitSet[3] |= 1 << 7 + requiredBitSet[4] |= 1 << 2 if err := func() error { s.RequiredArrayStringTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13715,7 +14899,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_time\"") } case "required_array_string_unix": - requiredBitSet[4] |= 1 << 0 + requiredBitSet[4] |= 1 << 3 if err := func() error { s.RequiredArrayStringUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13735,7 +14919,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix\"") } case "required_array_string_unix-micro": - requiredBitSet[4] |= 1 << 1 + requiredBitSet[4] |= 1 << 4 if err := func() error { s.RequiredArrayStringUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13755,7 +14939,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-micro\"") } case "required_array_string_unix-milli": - requiredBitSet[4] |= 1 << 2 + requiredBitSet[4] |= 1 << 5 if err := func() error { s.RequiredArrayStringUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13775,7 +14959,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-milli\"") } case "required_array_string_unix-nano": - requiredBitSet[4] |= 1 << 3 + requiredBitSet[4] |= 1 << 6 if err := func() error { s.RequiredArrayStringUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13795,7 +14979,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-nano\"") } case "required_array_string_unix-seconds": - requiredBitSet[4] |= 1 << 4 + requiredBitSet[4] |= 1 << 7 if err := func() error { s.RequiredArrayStringUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13815,7 +14999,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-seconds\"") } case "required_array_string_uri": - requiredBitSet[4] |= 1 << 5 + requiredBitSet[5] |= 1 << 0 if err := func() error { s.RequiredArrayStringURI = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13835,7 +15019,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uri\"") } case "required_array_string_uuid": - requiredBitSet[4] |= 1 << 6 + requiredBitSet[5] |= 1 << 1 if err := func() error { s.RequiredArrayStringUUID = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13855,7 +15039,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uuid\"") } case "required_boolean": - requiredBitSet[4] |= 1 << 7 + requiredBitSet[5] |= 1 << 2 if err := func() error { v, err := d.Bool() s.RequiredBoolean = bool(v) @@ -13867,7 +15051,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_boolean\"") } case "required_double_array_any": - requiredBitSet[5] |= 1 << 0 + requiredBitSet[5] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayAny = make([][]jx.Raw, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13895,7 +15079,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_any\"") } case "required_double_array_boolean": - requiredBitSet[5] |= 1 << 1 + requiredBitSet[5] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayBoolean = make([][]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13923,7 +15107,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_boolean\"") } case "required_double_array_integer": - requiredBitSet[5] |= 1 << 2 + requiredBitSet[5] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayInteger = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13951,7 +15135,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer\"") } case "required_double_array_integer_int32": - requiredBitSet[5] |= 1 << 3 + requiredBitSet[5] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13979,7 +15163,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int32\"") } case "required_double_array_integer_int64": - requiredBitSet[5] |= 1 << 4 + requiredBitSet[5] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14006,8 +15190,92 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_double_array_integer_int64\"") } + case "required_double_array_integer_uint": + requiredBitSet[6] |= 1 << 0 + if err := func() error { + s.RequiredDoubleArrayIntegerUint = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint = append(s.RequiredDoubleArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint\"") + } + case "required_double_array_integer_uint32": + requiredBitSet[6] |= 1 << 1 + if err := func() error { + s.RequiredDoubleArrayIntegerUint32 = make([][]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint32 + elem = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint32 = append(s.RequiredDoubleArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint32\"") + } + case "required_double_array_integer_uint64": + requiredBitSet[6] |= 1 << 2 + if err := func() error { + s.RequiredDoubleArrayIntegerUint64 = make([][]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint64 + elem = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint64 = append(s.RequiredDoubleArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint64\"") + } case "required_double_array_integer_unix": - requiredBitSet[5] |= 1 << 5 + requiredBitSet[6] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14035,7 +15303,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix\"") } case "required_double_array_integer_unix-micro": - requiredBitSet[5] |= 1 << 6 + requiredBitSet[6] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14063,7 +15331,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-micro\"") } case "required_double_array_integer_unix-milli": - requiredBitSet[5] |= 1 << 7 + requiredBitSet[6] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14091,7 +15359,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-milli\"") } case "required_double_array_integer_unix-nano": - requiredBitSet[6] |= 1 << 0 + requiredBitSet[6] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14119,7 +15387,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-nano\"") } case "required_double_array_integer_unix-seconds": - requiredBitSet[6] |= 1 << 1 + requiredBitSet[6] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14147,7 +15415,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-seconds\"") } case "required_double_array_null": - requiredBitSet[6] |= 1 << 2 + requiredBitSet[7] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayNull = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14173,7 +15441,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_null\"") } case "required_double_array_number": - requiredBitSet[6] |= 1 << 3 + requiredBitSet[7] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayNumber = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14201,7 +15469,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number\"") } case "required_double_array_number_double": - requiredBitSet[6] |= 1 << 4 + requiredBitSet[7] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayNumberDouble = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14229,7 +15497,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_double\"") } case "required_double_array_number_float": - requiredBitSet[6] |= 1 << 5 + requiredBitSet[7] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayNumberFloat = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14257,7 +15525,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_float\"") } case "required_double_array_number_int32": - requiredBitSet[6] |= 1 << 6 + requiredBitSet[7] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayNumberInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14285,7 +15553,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_int32\"") } case "required_double_array_number_int64": - requiredBitSet[6] |= 1 << 7 + requiredBitSet[7] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayNumberInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14313,7 +15581,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_int64\"") } case "required_double_array_string": - requiredBitSet[7] |= 1 << 0 + requiredBitSet[7] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayString = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14341,7 +15609,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string\"") } case "required_double_array_string_binary": - requiredBitSet[7] |= 1 << 1 + requiredBitSet[7] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringBinary = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14369,7 +15637,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_binary\"") } case "required_double_array_string_byte": - requiredBitSet[7] |= 1 << 2 + requiredBitSet[8] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringByte = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14397,7 +15665,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_byte\"") } case "required_double_array_string_date": - requiredBitSet[7] |= 1 << 3 + requiredBitSet[8] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringDate = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14425,7 +15693,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_date\"") } case "required_double_array_string_date-time": - requiredBitSet[7] |= 1 << 4 + requiredBitSet[8] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringDateMinusTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14453,7 +15721,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_date-time\"") } case "required_double_array_string_duration": - requiredBitSet[7] |= 1 << 5 + requiredBitSet[8] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringDuration = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14481,7 +15749,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_duration\"") } case "required_double_array_string_email": - requiredBitSet[7] |= 1 << 6 + requiredBitSet[8] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringEmail = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14509,7 +15777,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_email\"") } case "required_double_array_string_hostname": - requiredBitSet[7] |= 1 << 7 + requiredBitSet[8] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringHostname = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14537,7 +15805,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_hostname\"") } case "required_double_array_string_int32": - requiredBitSet[8] |= 1 << 0 + requiredBitSet[8] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14565,7 +15833,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int32\"") } case "required_double_array_string_int64": - requiredBitSet[8] |= 1 << 1 + requiredBitSet[8] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14593,7 +15861,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int64\"") } case "required_double_array_string_ip": - requiredBitSet[8] |= 1 << 2 + requiredBitSet[9] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringIP = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14621,7 +15889,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ip\"") } case "required_double_array_string_ipv4": - requiredBitSet[8] |= 1 << 3 + requiredBitSet[9] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringIpv4 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14649,7 +15917,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ipv4\"") } case "required_double_array_string_ipv6": - requiredBitSet[8] |= 1 << 4 + requiredBitSet[9] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringIpv6 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14677,7 +15945,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ipv6\"") } case "required_double_array_string_password": - requiredBitSet[8] |= 1 << 5 + requiredBitSet[9] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringPassword = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14705,7 +15973,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_password\"") } case "required_double_array_string_time": - requiredBitSet[8] |= 1 << 6 + requiredBitSet[9] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14733,7 +16001,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_time\"") } case "required_double_array_string_unix": - requiredBitSet[8] |= 1 << 7 + requiredBitSet[9] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14761,7 +16029,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix\"") } case "required_double_array_string_unix-micro": - requiredBitSet[9] |= 1 << 0 + requiredBitSet[9] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14789,7 +16057,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-micro\"") } case "required_double_array_string_unix-milli": - requiredBitSet[9] |= 1 << 1 + requiredBitSet[9] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14817,7 +16085,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-milli\"") } case "required_double_array_string_unix-nano": - requiredBitSet[9] |= 1 << 2 + requiredBitSet[10] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14845,7 +16113,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-nano\"") } case "required_double_array_string_unix-seconds": - requiredBitSet[9] |= 1 << 3 + requiredBitSet[10] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14873,7 +16141,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-seconds\"") } case "required_double_array_string_uri": - requiredBitSet[9] |= 1 << 4 + requiredBitSet[10] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringURI = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14901,7 +16169,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uri\"") } case "required_double_array_string_uuid": - requiredBitSet[9] |= 1 << 5 + requiredBitSet[10] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUUID = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -14929,7 +16197,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uuid\"") } case "required_integer": - requiredBitSet[9] |= 1 << 6 + requiredBitSet[10] |= 1 << 4 if err := func() error { v, err := d.Int() s.RequiredInteger = int(v) @@ -14941,7 +16209,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer\"") } case "required_integer_int32": - requiredBitSet[9] |= 1 << 7 + requiredBitSet[10] |= 1 << 5 if err := func() error { v, err := d.Int32() s.RequiredIntegerInt32 = int32(v) @@ -14953,7 +16221,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int32\"") } case "required_integer_int64": - requiredBitSet[10] |= 1 << 0 + requiredBitSet[10] |= 1 << 6 if err := func() error { v, err := d.Int64() s.RequiredIntegerInt64 = int64(v) @@ -14964,8 +16232,44 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_integer_int64\"") } + case "required_integer_uint": + requiredBitSet[10] |= 1 << 7 + if err := func() error { + v, err := d.UInt() + s.RequiredIntegerUint = uint(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint\"") + } + case "required_integer_uint32": + requiredBitSet[11] |= 1 << 0 + if err := func() error { + v, err := d.UInt32() + s.RequiredIntegerUint32 = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint32\"") + } + case "required_integer_uint64": + requiredBitSet[11] |= 1 << 1 + if err := func() error { + v, err := d.UInt64() + s.RequiredIntegerUint64 = uint64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint64\"") + } case "required_integer_unix": - requiredBitSet[10] |= 1 << 1 + requiredBitSet[11] |= 1 << 2 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnix = v @@ -14977,7 +16281,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix\"") } case "required_integer_unix-micro": - requiredBitSet[10] |= 1 << 2 + requiredBitSet[11] |= 1 << 3 if err := func() error { v, err := json.DecodeUnixMicro(d) s.RequiredIntegerUnixMinusMicro = v @@ -14989,7 +16293,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-micro\"") } case "required_integer_unix-milli": - requiredBitSet[10] |= 1 << 3 + requiredBitSet[11] |= 1 << 4 if err := func() error { v, err := json.DecodeUnixMilli(d) s.RequiredIntegerUnixMinusMilli = v @@ -15001,7 +16305,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-milli\"") } case "required_integer_unix-nano": - requiredBitSet[10] |= 1 << 4 + requiredBitSet[11] |= 1 << 5 if err := func() error { v, err := json.DecodeUnixNano(d) s.RequiredIntegerUnixMinusNano = v @@ -15013,7 +16317,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-nano\"") } case "required_integer_unix-seconds": - requiredBitSet[10] |= 1 << 5 + requiredBitSet[11] |= 1 << 6 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnixMinusSeconds = v @@ -15025,7 +16329,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-seconds\"") } case "required_null": - requiredBitSet[10] |= 1 << 6 + requiredBitSet[11] |= 1 << 7 if err := func() error { if err := d.Null(); err != nil { return err @@ -15035,7 +16339,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_null\"") } case "required_number": - requiredBitSet[10] |= 1 << 7 + requiredBitSet[12] |= 1 << 0 if err := func() error { v, err := d.Float64() s.RequiredNumber = float64(v) @@ -15047,7 +16351,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number\"") } case "required_number_double": - requiredBitSet[11] |= 1 << 0 + requiredBitSet[12] |= 1 << 1 if err := func() error { v, err := d.Float64() s.RequiredNumberDouble = float64(v) @@ -15059,7 +16363,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_double\"") } case "required_number_float": - requiredBitSet[11] |= 1 << 1 + requiredBitSet[12] |= 1 << 2 if err := func() error { v, err := d.Float32() s.RequiredNumberFloat = float32(v) @@ -15071,7 +16375,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_float\"") } case "required_number_int32": - requiredBitSet[11] |= 1 << 2 + requiredBitSet[12] |= 1 << 3 if err := func() error { v, err := d.Int32() s.RequiredNumberInt32 = int32(v) @@ -15083,7 +16387,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int32\"") } case "required_number_int64": - requiredBitSet[11] |= 1 << 3 + requiredBitSet[12] |= 1 << 4 if err := func() error { v, err := d.Int64() s.RequiredNumberInt64 = int64(v) @@ -15095,7 +16399,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int64\"") } case "required_string": - requiredBitSet[11] |= 1 << 4 + requiredBitSet[12] |= 1 << 5 if err := func() error { v, err := d.Str() s.RequiredString = string(v) @@ -15107,7 +16411,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string\"") } case "required_string_binary": - requiredBitSet[11] |= 1 << 5 + requiredBitSet[12] |= 1 << 6 if err := func() error { v, err := d.Str() s.RequiredStringBinary = string(v) @@ -15119,7 +16423,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_binary\"") } case "required_string_byte": - requiredBitSet[11] |= 1 << 6 + requiredBitSet[12] |= 1 << 7 if err := func() error { v, err := d.Base64() s.RequiredStringByte = []byte(v) @@ -15131,7 +16435,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_byte\"") } case "required_string_date": - requiredBitSet[11] |= 1 << 7 + requiredBitSet[13] |= 1 << 0 if err := func() error { v, err := json.DecodeDate(d) s.RequiredStringDate = v @@ -15143,7 +16447,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date\"") } case "required_string_date-time": - requiredBitSet[12] |= 1 << 0 + requiredBitSet[13] |= 1 << 1 if err := func() error { v, err := json.DecodeDateTime(d) s.RequiredStringDateMinusTime = v @@ -15155,7 +16459,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date-time\"") } case "required_string_duration": - requiredBitSet[12] |= 1 << 1 + requiredBitSet[13] |= 1 << 2 if err := func() error { v, err := json.DecodeDuration(d) s.RequiredStringDuration = v @@ -15167,7 +16471,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_duration\"") } case "required_string_email": - requiredBitSet[12] |= 1 << 2 + requiredBitSet[13] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringEmail = string(v) @@ -15179,7 +16483,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_email\"") } case "required_string_hostname": - requiredBitSet[12] |= 1 << 3 + requiredBitSet[13] |= 1 << 4 if err := func() error { v, err := d.Str() s.RequiredStringHostname = string(v) @@ -15191,7 +16495,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_hostname\"") } case "required_string_int32": - requiredBitSet[12] |= 1 << 4 + requiredBitSet[13] |= 1 << 5 if err := func() error { v, err := json.DecodeStringInt32(d) s.RequiredStringInt32 = v @@ -15203,7 +16507,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int32\"") } case "required_string_int64": - requiredBitSet[12] |= 1 << 5 + requiredBitSet[13] |= 1 << 6 if err := func() error { v, err := json.DecodeStringInt64(d) s.RequiredStringInt64 = v @@ -15215,7 +16519,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int64\"") } case "required_string_ip": - requiredBitSet[12] |= 1 << 6 + requiredBitSet[13] |= 1 << 7 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIP = v @@ -15227,7 +16531,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ip\"") } case "required_string_ipv4": - requiredBitSet[12] |= 1 << 7 + requiredBitSet[14] |= 1 << 0 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIpv4 = v @@ -15239,7 +16543,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv4\"") } case "required_string_ipv6": - requiredBitSet[13] |= 1 << 0 + requiredBitSet[14] |= 1 << 1 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIpv6 = v @@ -15251,7 +16555,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv6\"") } case "required_string_password": - requiredBitSet[13] |= 1 << 1 + requiredBitSet[14] |= 1 << 2 if err := func() error { v, err := d.Str() s.RequiredStringPassword = string(v) @@ -15263,7 +16567,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_password\"") } case "required_string_time": - requiredBitSet[13] |= 1 << 2 + requiredBitSet[14] |= 1 << 3 if err := func() error { v, err := json.DecodeTime(d) s.RequiredStringTime = v @@ -15275,7 +16579,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_time\"") } case "required_string_unix": - requiredBitSet[13] |= 1 << 3 + requiredBitSet[14] |= 1 << 4 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnix = v @@ -15287,7 +16591,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix\"") } case "required_string_unix-micro": - requiredBitSet[13] |= 1 << 4 + requiredBitSet[14] |= 1 << 5 if err := func() error { v, err := json.DecodeStringUnixMicro(d) s.RequiredStringUnixMinusMicro = v @@ -15299,7 +16603,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-micro\"") } case "required_string_unix-milli": - requiredBitSet[13] |= 1 << 5 + requiredBitSet[14] |= 1 << 6 if err := func() error { v, err := json.DecodeStringUnixMilli(d) s.RequiredStringUnixMinusMilli = v @@ -15311,7 +16615,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-milli\"") } case "required_string_unix-nano": - requiredBitSet[13] |= 1 << 6 + requiredBitSet[14] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUnixNano(d) s.RequiredStringUnixMinusNano = v @@ -15323,7 +16627,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-nano\"") } case "required_string_unix-seconds": - requiredBitSet[13] |= 1 << 7 + requiredBitSet[15] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnixMinusSeconds = v @@ -15335,7 +16639,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-seconds\"") } case "required_string_uri": - requiredBitSet[14] |= 1 << 0 + requiredBitSet[15] |= 1 << 1 if err := func() error { v, err := json.DecodeURI(d) s.RequiredStringURI = v @@ -15347,7 +16651,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uri\"") } case "required_string_uuid": - requiredBitSet[14] |= 1 << 1 + requiredBitSet[15] |= 1 << 2 if err := func() error { v, err := json.DecodeUUID(d) s.RequiredStringUUID = v @@ -15464,6 +16768,63 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_array_integer_int64\"") } + case "optional_array_integer_uint": + if err := func() error { + s.OptionalArrayIntegerUint = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint = append(s.OptionalArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint\"") + } + case "optional_array_integer_uint32": + if err := func() error { + s.OptionalArrayIntegerUint32 = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint32 = append(s.OptionalArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint32\"") + } + case "optional_array_integer_uint64": + if err := func() error { + s.OptionalArrayIntegerUint64 = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint64 = append(s.OptionalArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint64\"") + } case "optional_array_integer_unix": if err := func() error { s.OptionalArrayIntegerUnix = make([]time.Time, 0) @@ -16234,6 +17595,87 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_double_array_integer_int64\"") } + case "optional_double_array_integer_uint": + if err := func() error { + s.OptionalDoubleArrayIntegerUint = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint = append(s.OptionalDoubleArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint\"") + } + case "optional_double_array_integer_uint32": + if err := func() error { + s.OptionalDoubleArrayIntegerUint32 = make([][]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint32 + elem = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint32 = append(s.OptionalDoubleArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint32\"") + } + case "optional_double_array_integer_uint64": + if err := func() error { + s.OptionalDoubleArrayIntegerUint64 = make([][]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint64 + elem = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint64 = append(s.OptionalDoubleArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint64\"") + } case "optional_double_array_integer_unix": if err := func() error { s.OptionalDoubleArrayIntegerUnix = make([][]time.Time, 0) @@ -17153,6 +18595,36 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_integer_int64\"") } + case "optional_integer_uint": + if err := func() error { + s.OptionalIntegerUint.Reset() + if err := s.OptionalIntegerUint.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint\"") + } + case "optional_integer_uint32": + if err := func() error { + s.OptionalIntegerUint32.Reset() + if err := s.OptionalIntegerUint32.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint32\"") + } + case "optional_integer_uint64": + if err := func() error { + s.OptionalIntegerUint64.Reset() + if err := s.OptionalIntegerUint64.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint64\"") + } case "optional_integer_unix": if err := func() error { s.OptionalIntegerUnix.Reset() @@ -17493,7 +18965,8 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [29]uint8{ + for i, mask := range [31]uint8{ + 0b11111111, 0b11111111, 0b11111111, 0b11111111, @@ -17508,7 +18981,8 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { 0b11111111, 0b11111111, 0b11111111, - 0b00000011, + 0b00000111, + 0b00000000, 0b00000000, 0b00000000, 0b00000000, @@ -17676,6 +19150,33 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + + e.FieldStart("required_array_integer_uint") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint { + e.UInt(elem) + } + e.ArrEnd() + } + { + + e.FieldStart("required_array_integer_uint32") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint32 { + e.UInt32(elem) + } + e.ArrEnd() + } + { + + e.FieldStart("required_array_integer_uint64") + e.ArrStart() + for _, elem := range s.RequiredArrayIntegerUint64 { + e.UInt64(elem) + } + e.ArrEnd() + } { e.FieldStart("required_array_integer_unix") @@ -18009,12 +19510,51 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } { - e.FieldStart("required_double_array_integer") + e.FieldStart("required_double_array_integer") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayInteger { + e.ArrStart() + for _, elem := range elem { + e.Int(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + { + + e.FieldStart("required_double_array_integer_int32") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerInt32 { + e.ArrStart() + for _, elem := range elem { + e.Int32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + { + + e.FieldStart("required_double_array_integer_int64") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayIntegerInt64 { + e.ArrStart() + for _, elem := range elem { + e.Int64(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + { + + e.FieldStart("required_double_array_integer_uint") e.ArrStart() - for _, elem := range s.RequiredDoubleArrayInteger { + for _, elem := range s.RequiredDoubleArrayIntegerUint { e.ArrStart() for _, elem := range elem { - e.Int(elem) + e.UInt(elem) } e.ArrEnd() } @@ -18022,12 +19562,12 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } { - e.FieldStart("required_double_array_integer_int32") + e.FieldStart("required_double_array_integer_uint32") e.ArrStart() - for _, elem := range s.RequiredDoubleArrayIntegerInt32 { + for _, elem := range s.RequiredDoubleArrayIntegerUint32 { e.ArrStart() for _, elem := range elem { - e.Int32(elem) + e.UInt32(elem) } e.ArrEnd() } @@ -18035,12 +19575,12 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } { - e.FieldStart("required_double_array_integer_int64") + e.FieldStart("required_double_array_integer_uint64") e.ArrStart() - for _, elem := range s.RequiredDoubleArrayIntegerInt64 { + for _, elem := range s.RequiredDoubleArrayIntegerUint64 { e.ArrStart() for _, elem := range elem { - e.Int64(elem) + e.UInt64(elem) } e.ArrEnd() } @@ -18491,6 +20031,21 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { e.FieldStart("required_integer_int64") e.Int64(s.RequiredIntegerInt64) } + { + + e.FieldStart("required_integer_uint") + e.UInt(s.RequiredIntegerUint) + } + { + + e.FieldStart("required_integer_uint32") + e.UInt32(s.RequiredIntegerUint32) + } + { + + e.FieldStart("required_integer_uint64") + e.UInt64(s.RequiredIntegerUint64) + } { e.FieldStart("required_integer_unix") @@ -18716,6 +20271,36 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalArrayIntegerUint != nil { + e.FieldStart("optional_array_integer_uint") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint { + e.UInt(elem) + } + e.ArrEnd() + } + } + { + if s.OptionalArrayIntegerUint32 != nil { + e.FieldStart("optional_array_integer_uint32") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint32 { + e.UInt32(elem) + } + e.ArrEnd() + } + } + { + if s.OptionalArrayIntegerUint64 != nil { + e.FieldStart("optional_array_integer_uint64") + e.ArrStart() + for _, elem := range s.OptionalArrayIntegerUint64 { + e.UInt64(elem) + } + e.ArrEnd() + } + } { if s.OptionalArrayIntegerUnix != nil { e.FieldStart("optional_array_integer_unix") @@ -19125,6 +20710,48 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalDoubleArrayIntegerUint != nil { + e.FieldStart("optional_double_array_integer_uint") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerUint { + e.ArrStart() + for _, elem := range elem { + e.UInt(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + { + if s.OptionalDoubleArrayIntegerUint32 != nil { + e.FieldStart("optional_double_array_integer_uint32") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerUint32 { + e.ArrStart() + for _, elem := range elem { + e.UInt32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + { + if s.OptionalDoubleArrayIntegerUint64 != nil { + e.FieldStart("optional_double_array_integer_uint64") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayIntegerUint64 { + e.ArrStart() + for _, elem := range elem { + e.UInt64(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } { if s.OptionalDoubleArrayIntegerUnix != nil { e.FieldStart("optional_double_array_integer_unix") @@ -19606,6 +21233,24 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { s.OptionalIntegerInt64.Encode(e) } } + { + if s.OptionalIntegerUint.Set { + e.FieldStart("optional_integer_uint") + s.OptionalIntegerUint.Encode(e) + } + } + { + if s.OptionalIntegerUint32.Set { + e.FieldStart("optional_integer_uint32") + s.OptionalIntegerUint32.Encode(e) + } + } + { + if s.OptionalIntegerUint64.Set { + e.FieldStart("optional_integer_uint64") + s.OptionalIntegerUint64.Encode(e) + } + } { if s.OptionalIntegerUnix.Set { e.FieldStart("optional_integer_unix") @@ -19805,235 +21450,253 @@ func (s TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfTestResponseFormatTestOK = [228]string{ +var jsonFieldsNameOfTestResponseFormatTestOK = [246]string{ 0: "required_any", 1: "required_array_any", 2: "required_array_boolean", 3: "required_array_integer", 4: "required_array_integer_int32", 5: "required_array_integer_int64", - 6: "required_array_integer_unix", - 7: "required_array_integer_unix-micro", - 8: "required_array_integer_unix-milli", - 9: "required_array_integer_unix-nano", - 10: "required_array_integer_unix-seconds", - 11: "required_array_null", - 12: "required_array_number", - 13: "required_array_number_double", - 14: "required_array_number_float", - 15: "required_array_number_int32", - 16: "required_array_number_int64", - 17: "required_array_string", - 18: "required_array_string_binary", - 19: "required_array_string_byte", - 20: "required_array_string_date", - 21: "required_array_string_date-time", - 22: "required_array_string_duration", - 23: "required_array_string_email", - 24: "required_array_string_hostname", - 25: "required_array_string_int32", - 26: "required_array_string_int64", - 27: "required_array_string_ip", - 28: "required_array_string_ipv4", - 29: "required_array_string_ipv6", - 30: "required_array_string_password", - 31: "required_array_string_time", - 32: "required_array_string_unix", - 33: "required_array_string_unix-micro", - 34: "required_array_string_unix-milli", - 35: "required_array_string_unix-nano", - 36: "required_array_string_unix-seconds", - 37: "required_array_string_uri", - 38: "required_array_string_uuid", - 39: "required_boolean", - 40: "required_double_array_any", - 41: "required_double_array_boolean", - 42: "required_double_array_integer", - 43: "required_double_array_integer_int32", - 44: "required_double_array_integer_int64", - 45: "required_double_array_integer_unix", - 46: "required_double_array_integer_unix-micro", - 47: "required_double_array_integer_unix-milli", - 48: "required_double_array_integer_unix-nano", - 49: "required_double_array_integer_unix-seconds", - 50: "required_double_array_null", - 51: "required_double_array_number", - 52: "required_double_array_number_double", - 53: "required_double_array_number_float", - 54: "required_double_array_number_int32", - 55: "required_double_array_number_int64", - 56: "required_double_array_string", - 57: "required_double_array_string_binary", - 58: "required_double_array_string_byte", - 59: "required_double_array_string_date", - 60: "required_double_array_string_date-time", - 61: "required_double_array_string_duration", - 62: "required_double_array_string_email", - 63: "required_double_array_string_hostname", - 64: "required_double_array_string_int32", - 65: "required_double_array_string_int64", - 66: "required_double_array_string_ip", - 67: "required_double_array_string_ipv4", - 68: "required_double_array_string_ipv6", - 69: "required_double_array_string_password", - 70: "required_double_array_string_time", - 71: "required_double_array_string_unix", - 72: "required_double_array_string_unix-micro", - 73: "required_double_array_string_unix-milli", - 74: "required_double_array_string_unix-nano", - 75: "required_double_array_string_unix-seconds", - 76: "required_double_array_string_uri", - 77: "required_double_array_string_uuid", - 78: "required_integer", - 79: "required_integer_int32", - 80: "required_integer_int64", - 81: "required_integer_unix", - 82: "required_integer_unix-micro", - 83: "required_integer_unix-milli", - 84: "required_integer_unix-nano", - 85: "required_integer_unix-seconds", - 86: "required_null", - 87: "required_number", - 88: "required_number_double", - 89: "required_number_float", - 90: "required_number_int32", - 91: "required_number_int64", - 92: "required_string", - 93: "required_string_binary", - 94: "required_string_byte", - 95: "required_string_date", - 96: "required_string_date-time", - 97: "required_string_duration", - 98: "required_string_email", - 99: "required_string_hostname", - 100: "required_string_int32", - 101: "required_string_int64", - 102: "required_string_ip", - 103: "required_string_ipv4", - 104: "required_string_ipv6", - 105: "required_string_password", - 106: "required_string_time", - 107: "required_string_unix", - 108: "required_string_unix-micro", - 109: "required_string_unix-milli", - 110: "required_string_unix-nano", - 111: "required_string_unix-seconds", - 112: "required_string_uri", - 113: "required_string_uuid", - 114: "optional_any", - 115: "optional_array_any", - 116: "optional_array_boolean", - 117: "optional_array_integer", - 118: "optional_array_integer_int32", - 119: "optional_array_integer_int64", - 120: "optional_array_integer_unix", - 121: "optional_array_integer_unix-micro", - 122: "optional_array_integer_unix-milli", - 123: "optional_array_integer_unix-nano", - 124: "optional_array_integer_unix-seconds", - 125: "optional_array_null", - 126: "optional_array_number", - 127: "optional_array_number_double", - 128: "optional_array_number_float", - 129: "optional_array_number_int32", - 130: "optional_array_number_int64", - 131: "optional_array_string", - 132: "optional_array_string_binary", - 133: "optional_array_string_byte", - 134: "optional_array_string_date", - 135: "optional_array_string_date-time", - 136: "optional_array_string_duration", - 137: "optional_array_string_email", - 138: "optional_array_string_hostname", - 139: "optional_array_string_int32", - 140: "optional_array_string_int64", - 141: "optional_array_string_ip", - 142: "optional_array_string_ipv4", - 143: "optional_array_string_ipv6", - 144: "optional_array_string_password", - 145: "optional_array_string_time", - 146: "optional_array_string_unix", - 147: "optional_array_string_unix-micro", - 148: "optional_array_string_unix-milli", - 149: "optional_array_string_unix-nano", - 150: "optional_array_string_unix-seconds", - 151: "optional_array_string_uri", - 152: "optional_array_string_uuid", - 153: "optional_boolean", - 154: "optional_double_array_any", - 155: "optional_double_array_boolean", - 156: "optional_double_array_integer", - 157: "optional_double_array_integer_int32", - 158: "optional_double_array_integer_int64", - 159: "optional_double_array_integer_unix", - 160: "optional_double_array_integer_unix-micro", - 161: "optional_double_array_integer_unix-milli", - 162: "optional_double_array_integer_unix-nano", - 163: "optional_double_array_integer_unix-seconds", - 164: "optional_double_array_null", - 165: "optional_double_array_number", - 166: "optional_double_array_number_double", - 167: "optional_double_array_number_float", - 168: "optional_double_array_number_int32", - 169: "optional_double_array_number_int64", - 170: "optional_double_array_string", - 171: "optional_double_array_string_binary", - 172: "optional_double_array_string_byte", - 173: "optional_double_array_string_date", - 174: "optional_double_array_string_date-time", - 175: "optional_double_array_string_duration", - 176: "optional_double_array_string_email", - 177: "optional_double_array_string_hostname", - 178: "optional_double_array_string_int32", - 179: "optional_double_array_string_int64", - 180: "optional_double_array_string_ip", - 181: "optional_double_array_string_ipv4", - 182: "optional_double_array_string_ipv6", - 183: "optional_double_array_string_password", - 184: "optional_double_array_string_time", - 185: "optional_double_array_string_unix", - 186: "optional_double_array_string_unix-micro", - 187: "optional_double_array_string_unix-milli", - 188: "optional_double_array_string_unix-nano", - 189: "optional_double_array_string_unix-seconds", - 190: "optional_double_array_string_uri", - 191: "optional_double_array_string_uuid", - 192: "optional_integer", - 193: "optional_integer_int32", - 194: "optional_integer_int64", - 195: "optional_integer_unix", - 196: "optional_integer_unix-micro", - 197: "optional_integer_unix-milli", - 198: "optional_integer_unix-nano", - 199: "optional_integer_unix-seconds", - 200: "optional_null", - 201: "optional_number", - 202: "optional_number_double", - 203: "optional_number_float", - 204: "optional_number_int32", - 205: "optional_number_int64", - 206: "optional_string", - 207: "optional_string_binary", - 208: "optional_string_byte", - 209: "optional_string_date", - 210: "optional_string_date-time", - 211: "optional_string_duration", - 212: "optional_string_email", - 213: "optional_string_hostname", - 214: "optional_string_int32", - 215: "optional_string_int64", - 216: "optional_string_ip", - 217: "optional_string_ipv4", - 218: "optional_string_ipv6", - 219: "optional_string_password", - 220: "optional_string_time", - 221: "optional_string_unix", - 222: "optional_string_unix-micro", - 223: "optional_string_unix-milli", - 224: "optional_string_unix-nano", - 225: "optional_string_unix-seconds", - 226: "optional_string_uri", - 227: "optional_string_uuid", + 6: "required_array_integer_uint", + 7: "required_array_integer_uint32", + 8: "required_array_integer_uint64", + 9: "required_array_integer_unix", + 10: "required_array_integer_unix-micro", + 11: "required_array_integer_unix-milli", + 12: "required_array_integer_unix-nano", + 13: "required_array_integer_unix-seconds", + 14: "required_array_null", + 15: "required_array_number", + 16: "required_array_number_double", + 17: "required_array_number_float", + 18: "required_array_number_int32", + 19: "required_array_number_int64", + 20: "required_array_string", + 21: "required_array_string_binary", + 22: "required_array_string_byte", + 23: "required_array_string_date", + 24: "required_array_string_date-time", + 25: "required_array_string_duration", + 26: "required_array_string_email", + 27: "required_array_string_hostname", + 28: "required_array_string_int32", + 29: "required_array_string_int64", + 30: "required_array_string_ip", + 31: "required_array_string_ipv4", + 32: "required_array_string_ipv6", + 33: "required_array_string_password", + 34: "required_array_string_time", + 35: "required_array_string_unix", + 36: "required_array_string_unix-micro", + 37: "required_array_string_unix-milli", + 38: "required_array_string_unix-nano", + 39: "required_array_string_unix-seconds", + 40: "required_array_string_uri", + 41: "required_array_string_uuid", + 42: "required_boolean", + 43: "required_double_array_any", + 44: "required_double_array_boolean", + 45: "required_double_array_integer", + 46: "required_double_array_integer_int32", + 47: "required_double_array_integer_int64", + 48: "required_double_array_integer_uint", + 49: "required_double_array_integer_uint32", + 50: "required_double_array_integer_uint64", + 51: "required_double_array_integer_unix", + 52: "required_double_array_integer_unix-micro", + 53: "required_double_array_integer_unix-milli", + 54: "required_double_array_integer_unix-nano", + 55: "required_double_array_integer_unix-seconds", + 56: "required_double_array_null", + 57: "required_double_array_number", + 58: "required_double_array_number_double", + 59: "required_double_array_number_float", + 60: "required_double_array_number_int32", + 61: "required_double_array_number_int64", + 62: "required_double_array_string", + 63: "required_double_array_string_binary", + 64: "required_double_array_string_byte", + 65: "required_double_array_string_date", + 66: "required_double_array_string_date-time", + 67: "required_double_array_string_duration", + 68: "required_double_array_string_email", + 69: "required_double_array_string_hostname", + 70: "required_double_array_string_int32", + 71: "required_double_array_string_int64", + 72: "required_double_array_string_ip", + 73: "required_double_array_string_ipv4", + 74: "required_double_array_string_ipv6", + 75: "required_double_array_string_password", + 76: "required_double_array_string_time", + 77: "required_double_array_string_unix", + 78: "required_double_array_string_unix-micro", + 79: "required_double_array_string_unix-milli", + 80: "required_double_array_string_unix-nano", + 81: "required_double_array_string_unix-seconds", + 82: "required_double_array_string_uri", + 83: "required_double_array_string_uuid", + 84: "required_integer", + 85: "required_integer_int32", + 86: "required_integer_int64", + 87: "required_integer_uint", + 88: "required_integer_uint32", + 89: "required_integer_uint64", + 90: "required_integer_unix", + 91: "required_integer_unix-micro", + 92: "required_integer_unix-milli", + 93: "required_integer_unix-nano", + 94: "required_integer_unix-seconds", + 95: "required_null", + 96: "required_number", + 97: "required_number_double", + 98: "required_number_float", + 99: "required_number_int32", + 100: "required_number_int64", + 101: "required_string", + 102: "required_string_binary", + 103: "required_string_byte", + 104: "required_string_date", + 105: "required_string_date-time", + 106: "required_string_duration", + 107: "required_string_email", + 108: "required_string_hostname", + 109: "required_string_int32", + 110: "required_string_int64", + 111: "required_string_ip", + 112: "required_string_ipv4", + 113: "required_string_ipv6", + 114: "required_string_password", + 115: "required_string_time", + 116: "required_string_unix", + 117: "required_string_unix-micro", + 118: "required_string_unix-milli", + 119: "required_string_unix-nano", + 120: "required_string_unix-seconds", + 121: "required_string_uri", + 122: "required_string_uuid", + 123: "optional_any", + 124: "optional_array_any", + 125: "optional_array_boolean", + 126: "optional_array_integer", + 127: "optional_array_integer_int32", + 128: "optional_array_integer_int64", + 129: "optional_array_integer_uint", + 130: "optional_array_integer_uint32", + 131: "optional_array_integer_uint64", + 132: "optional_array_integer_unix", + 133: "optional_array_integer_unix-micro", + 134: "optional_array_integer_unix-milli", + 135: "optional_array_integer_unix-nano", + 136: "optional_array_integer_unix-seconds", + 137: "optional_array_null", + 138: "optional_array_number", + 139: "optional_array_number_double", + 140: "optional_array_number_float", + 141: "optional_array_number_int32", + 142: "optional_array_number_int64", + 143: "optional_array_string", + 144: "optional_array_string_binary", + 145: "optional_array_string_byte", + 146: "optional_array_string_date", + 147: "optional_array_string_date-time", + 148: "optional_array_string_duration", + 149: "optional_array_string_email", + 150: "optional_array_string_hostname", + 151: "optional_array_string_int32", + 152: "optional_array_string_int64", + 153: "optional_array_string_ip", + 154: "optional_array_string_ipv4", + 155: "optional_array_string_ipv6", + 156: "optional_array_string_password", + 157: "optional_array_string_time", + 158: "optional_array_string_unix", + 159: "optional_array_string_unix-micro", + 160: "optional_array_string_unix-milli", + 161: "optional_array_string_unix-nano", + 162: "optional_array_string_unix-seconds", + 163: "optional_array_string_uri", + 164: "optional_array_string_uuid", + 165: "optional_boolean", + 166: "optional_double_array_any", + 167: "optional_double_array_boolean", + 168: "optional_double_array_integer", + 169: "optional_double_array_integer_int32", + 170: "optional_double_array_integer_int64", + 171: "optional_double_array_integer_uint", + 172: "optional_double_array_integer_uint32", + 173: "optional_double_array_integer_uint64", + 174: "optional_double_array_integer_unix", + 175: "optional_double_array_integer_unix-micro", + 176: "optional_double_array_integer_unix-milli", + 177: "optional_double_array_integer_unix-nano", + 178: "optional_double_array_integer_unix-seconds", + 179: "optional_double_array_null", + 180: "optional_double_array_number", + 181: "optional_double_array_number_double", + 182: "optional_double_array_number_float", + 183: "optional_double_array_number_int32", + 184: "optional_double_array_number_int64", + 185: "optional_double_array_string", + 186: "optional_double_array_string_binary", + 187: "optional_double_array_string_byte", + 188: "optional_double_array_string_date", + 189: "optional_double_array_string_date-time", + 190: "optional_double_array_string_duration", + 191: "optional_double_array_string_email", + 192: "optional_double_array_string_hostname", + 193: "optional_double_array_string_int32", + 194: "optional_double_array_string_int64", + 195: "optional_double_array_string_ip", + 196: "optional_double_array_string_ipv4", + 197: "optional_double_array_string_ipv6", + 198: "optional_double_array_string_password", + 199: "optional_double_array_string_time", + 200: "optional_double_array_string_unix", + 201: "optional_double_array_string_unix-micro", + 202: "optional_double_array_string_unix-milli", + 203: "optional_double_array_string_unix-nano", + 204: "optional_double_array_string_unix-seconds", + 205: "optional_double_array_string_uri", + 206: "optional_double_array_string_uuid", + 207: "optional_integer", + 208: "optional_integer_int32", + 209: "optional_integer_int64", + 210: "optional_integer_uint", + 211: "optional_integer_uint32", + 212: "optional_integer_uint64", + 213: "optional_integer_unix", + 214: "optional_integer_unix-micro", + 215: "optional_integer_unix-milli", + 216: "optional_integer_unix-nano", + 217: "optional_integer_unix-seconds", + 218: "optional_null", + 219: "optional_number", + 220: "optional_number_double", + 221: "optional_number_float", + 222: "optional_number_int32", + 223: "optional_number_int64", + 224: "optional_string", + 225: "optional_string_binary", + 226: "optional_string_byte", + 227: "optional_string_date", + 228: "optional_string_date-time", + 229: "optional_string_duration", + 230: "optional_string_email", + 231: "optional_string_hostname", + 232: "optional_string_int32", + 233: "optional_string_int64", + 234: "optional_string_ip", + 235: "optional_string_ipv4", + 236: "optional_string_ipv6", + 237: "optional_string_password", + 238: "optional_string_time", + 239: "optional_string_unix", + 240: "optional_string_unix-micro", + 241: "optional_string_unix-milli", + 242: "optional_string_unix-nano", + 243: "optional_string_unix-seconds", + 244: "optional_string_uri", + 245: "optional_string_uuid", } // Decode decodes TestResponseFormatTestOK from json. @@ -20041,7 +21704,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode TestResponseFormatTestOK to nil") } - var requiredBitSet [29]uint8 + var requiredBitSet [31]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -20157,8 +21820,68 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_array_integer_int64\"") } - case "required_array_integer_unix": + case "required_array_integer_uint": requiredBitSet[0] |= 1 << 6 + if err := func() error { + s.RequiredArrayIntegerUint = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + s.RequiredArrayIntegerUint = append(s.RequiredArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_uint\"") + } + case "required_array_integer_uint32": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + s.RequiredArrayIntegerUint32 = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) + if err != nil { + return err + } + s.RequiredArrayIntegerUint32 = append(s.RequiredArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_uint32\"") + } + case "required_array_integer_uint64": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + s.RequiredArrayIntegerUint64 = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) + if err != nil { + return err + } + s.RequiredArrayIntegerUint64 = append(s.RequiredArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_integer_uint64\"") + } + case "required_array_integer_unix": + requiredBitSet[1] |= 1 << 1 if err := func() error { s.RequiredArrayIntegerUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20178,7 +21901,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix\"") } case "required_array_integer_unix-micro": - requiredBitSet[0] |= 1 << 7 + requiredBitSet[1] |= 1 << 2 if err := func() error { s.RequiredArrayIntegerUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20198,7 +21921,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-micro\"") } case "required_array_integer_unix-milli": - requiredBitSet[1] |= 1 << 0 + requiredBitSet[1] |= 1 << 3 if err := func() error { s.RequiredArrayIntegerUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20218,7 +21941,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-milli\"") } case "required_array_integer_unix-nano": - requiredBitSet[1] |= 1 << 1 + requiredBitSet[1] |= 1 << 4 if err := func() error { s.RequiredArrayIntegerUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20238,7 +21961,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-nano\"") } case "required_array_integer_unix-seconds": - requiredBitSet[1] |= 1 << 2 + requiredBitSet[1] |= 1 << 5 if err := func() error { s.RequiredArrayIntegerUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20258,7 +21981,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_integer_unix-seconds\"") } case "required_array_null": - requiredBitSet[1] |= 1 << 3 + requiredBitSet[1] |= 1 << 6 if err := func() error { s.RequiredArrayNull = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20276,7 +21999,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_null\"") } case "required_array_number": - requiredBitSet[1] |= 1 << 4 + requiredBitSet[1] |= 1 << 7 if err := func() error { s.RequiredArrayNumber = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20296,7 +22019,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number\"") } case "required_array_number_double": - requiredBitSet[1] |= 1 << 5 + requiredBitSet[2] |= 1 << 0 if err := func() error { s.RequiredArrayNumberDouble = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20316,7 +22039,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_double\"") } case "required_array_number_float": - requiredBitSet[1] |= 1 << 6 + requiredBitSet[2] |= 1 << 1 if err := func() error { s.RequiredArrayNumberFloat = make([]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20336,7 +22059,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_float\"") } case "required_array_number_int32": - requiredBitSet[1] |= 1 << 7 + requiredBitSet[2] |= 1 << 2 if err := func() error { s.RequiredArrayNumberInt32 = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20356,7 +22079,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_int32\"") } case "required_array_number_int64": - requiredBitSet[2] |= 1 << 0 + requiredBitSet[2] |= 1 << 3 if err := func() error { s.RequiredArrayNumberInt64 = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20376,7 +22099,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_number_int64\"") } case "required_array_string": - requiredBitSet[2] |= 1 << 1 + requiredBitSet[2] |= 1 << 4 if err := func() error { s.RequiredArrayString = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20396,7 +22119,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string\"") } case "required_array_string_binary": - requiredBitSet[2] |= 1 << 2 + requiredBitSet[2] |= 1 << 5 if err := func() error { s.RequiredArrayStringBinary = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20416,7 +22139,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_binary\"") } case "required_array_string_byte": - requiredBitSet[2] |= 1 << 3 + requiredBitSet[2] |= 1 << 6 if err := func() error { s.RequiredArrayStringByte = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20436,7 +22159,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_byte\"") } case "required_array_string_date": - requiredBitSet[2] |= 1 << 4 + requiredBitSet[2] |= 1 << 7 if err := func() error { s.RequiredArrayStringDate = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20456,7 +22179,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_date\"") } case "required_array_string_date-time": - requiredBitSet[2] |= 1 << 5 + requiredBitSet[3] |= 1 << 0 if err := func() error { s.RequiredArrayStringDateMinusTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20476,7 +22199,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_date-time\"") } case "required_array_string_duration": - requiredBitSet[2] |= 1 << 6 + requiredBitSet[3] |= 1 << 1 if err := func() error { s.RequiredArrayStringDuration = make([]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20496,7 +22219,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_duration\"") } case "required_array_string_email": - requiredBitSet[2] |= 1 << 7 + requiredBitSet[3] |= 1 << 2 if err := func() error { s.RequiredArrayStringEmail = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20516,7 +22239,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_email\"") } case "required_array_string_hostname": - requiredBitSet[3] |= 1 << 0 + requiredBitSet[3] |= 1 << 3 if err := func() error { s.RequiredArrayStringHostname = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20536,7 +22259,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_hostname\"") } case "required_array_string_int32": - requiredBitSet[3] |= 1 << 1 + requiredBitSet[3] |= 1 << 4 if err := func() error { s.RequiredArrayStringInt32 = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20556,7 +22279,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_int32\"") } case "required_array_string_int64": - requiredBitSet[3] |= 1 << 2 + requiredBitSet[3] |= 1 << 5 if err := func() error { s.RequiredArrayStringInt64 = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20576,7 +22299,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_int64\"") } case "required_array_string_ip": - requiredBitSet[3] |= 1 << 3 + requiredBitSet[3] |= 1 << 6 if err := func() error { s.RequiredArrayStringIP = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20596,7 +22319,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ip\"") } case "required_array_string_ipv4": - requiredBitSet[3] |= 1 << 4 + requiredBitSet[3] |= 1 << 7 if err := func() error { s.RequiredArrayStringIpv4 = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20616,7 +22339,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ipv4\"") } case "required_array_string_ipv6": - requiredBitSet[3] |= 1 << 5 + requiredBitSet[4] |= 1 << 0 if err := func() error { s.RequiredArrayStringIpv6 = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20636,7 +22359,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_ipv6\"") } case "required_array_string_password": - requiredBitSet[3] |= 1 << 6 + requiredBitSet[4] |= 1 << 1 if err := func() error { s.RequiredArrayStringPassword = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20656,7 +22379,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_password\"") } case "required_array_string_time": - requiredBitSet[3] |= 1 << 7 + requiredBitSet[4] |= 1 << 2 if err := func() error { s.RequiredArrayStringTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20676,7 +22399,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_time\"") } case "required_array_string_unix": - requiredBitSet[4] |= 1 << 0 + requiredBitSet[4] |= 1 << 3 if err := func() error { s.RequiredArrayStringUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20696,7 +22419,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix\"") } case "required_array_string_unix-micro": - requiredBitSet[4] |= 1 << 1 + requiredBitSet[4] |= 1 << 4 if err := func() error { s.RequiredArrayStringUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20716,7 +22439,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-micro\"") } case "required_array_string_unix-milli": - requiredBitSet[4] |= 1 << 2 + requiredBitSet[4] |= 1 << 5 if err := func() error { s.RequiredArrayStringUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20736,7 +22459,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-milli\"") } case "required_array_string_unix-nano": - requiredBitSet[4] |= 1 << 3 + requiredBitSet[4] |= 1 << 6 if err := func() error { s.RequiredArrayStringUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20756,7 +22479,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-nano\"") } case "required_array_string_unix-seconds": - requiredBitSet[4] |= 1 << 4 + requiredBitSet[4] |= 1 << 7 if err := func() error { s.RequiredArrayStringUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20776,7 +22499,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_unix-seconds\"") } case "required_array_string_uri": - requiredBitSet[4] |= 1 << 5 + requiredBitSet[5] |= 1 << 0 if err := func() error { s.RequiredArrayStringURI = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20796,7 +22519,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uri\"") } case "required_array_string_uuid": - requiredBitSet[4] |= 1 << 6 + requiredBitSet[5] |= 1 << 1 if err := func() error { s.RequiredArrayStringUUID = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20816,7 +22539,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uuid\"") } case "required_boolean": - requiredBitSet[4] |= 1 << 7 + requiredBitSet[5] |= 1 << 2 if err := func() error { v, err := d.Bool() s.RequiredBoolean = bool(v) @@ -20828,7 +22551,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_boolean\"") } case "required_double_array_any": - requiredBitSet[5] |= 1 << 0 + requiredBitSet[5] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayAny = make([][]jx.Raw, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20856,7 +22579,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_any\"") } case "required_double_array_boolean": - requiredBitSet[5] |= 1 << 1 + requiredBitSet[5] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayBoolean = make([][]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20884,7 +22607,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_boolean\"") } case "required_double_array_integer": - requiredBitSet[5] |= 1 << 2 + requiredBitSet[5] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayInteger = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20912,7 +22635,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer\"") } case "required_double_array_integer_int32": - requiredBitSet[5] |= 1 << 3 + requiredBitSet[5] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20940,7 +22663,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int32\"") } case "required_double_array_integer_int64": - requiredBitSet[5] |= 1 << 4 + requiredBitSet[5] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20967,8 +22690,92 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_double_array_integer_int64\"") } + case "required_double_array_integer_uint": + requiredBitSet[6] |= 1 << 0 + if err := func() error { + s.RequiredDoubleArrayIntegerUint = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint = append(s.RequiredDoubleArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint\"") + } + case "required_double_array_integer_uint32": + requiredBitSet[6] |= 1 << 1 + if err := func() error { + s.RequiredDoubleArrayIntegerUint32 = make([][]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint32 + elem = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint32 = append(s.RequiredDoubleArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint32\"") + } + case "required_double_array_integer_uint64": + requiredBitSet[6] |= 1 << 2 + if err := func() error { + s.RequiredDoubleArrayIntegerUint64 = make([][]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint64 + elem = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayIntegerUint64 = append(s.RequiredDoubleArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_integer_uint64\"") + } case "required_double_array_integer_unix": - requiredBitSet[5] |= 1 << 5 + requiredBitSet[6] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20996,7 +22803,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix\"") } case "required_double_array_integer_unix-micro": - requiredBitSet[5] |= 1 << 6 + requiredBitSet[6] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21024,7 +22831,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-micro\"") } case "required_double_array_integer_unix-milli": - requiredBitSet[5] |= 1 << 7 + requiredBitSet[6] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21052,7 +22859,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-milli\"") } case "required_double_array_integer_unix-nano": - requiredBitSet[6] |= 1 << 0 + requiredBitSet[6] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21080,7 +22887,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-nano\"") } case "required_double_array_integer_unix-seconds": - requiredBitSet[6] |= 1 << 1 + requiredBitSet[6] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21108,7 +22915,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_unix-seconds\"") } case "required_double_array_null": - requiredBitSet[6] |= 1 << 2 + requiredBitSet[7] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayNull = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21134,7 +22941,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_null\"") } case "required_double_array_number": - requiredBitSet[6] |= 1 << 3 + requiredBitSet[7] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayNumber = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21162,7 +22969,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number\"") } case "required_double_array_number_double": - requiredBitSet[6] |= 1 << 4 + requiredBitSet[7] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayNumberDouble = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21190,7 +22997,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_double\"") } case "required_double_array_number_float": - requiredBitSet[6] |= 1 << 5 + requiredBitSet[7] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayNumberFloat = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21218,7 +23025,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_float\"") } case "required_double_array_number_int32": - requiredBitSet[6] |= 1 << 6 + requiredBitSet[7] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayNumberInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21246,7 +23053,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_int32\"") } case "required_double_array_number_int64": - requiredBitSet[6] |= 1 << 7 + requiredBitSet[7] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayNumberInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21274,7 +23081,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_number_int64\"") } case "required_double_array_string": - requiredBitSet[7] |= 1 << 0 + requiredBitSet[7] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayString = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21302,7 +23109,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string\"") } case "required_double_array_string_binary": - requiredBitSet[7] |= 1 << 1 + requiredBitSet[7] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringBinary = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21330,7 +23137,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_binary\"") } case "required_double_array_string_byte": - requiredBitSet[7] |= 1 << 2 + requiredBitSet[8] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringByte = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21358,7 +23165,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_byte\"") } case "required_double_array_string_date": - requiredBitSet[7] |= 1 << 3 + requiredBitSet[8] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringDate = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21386,7 +23193,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_date\"") } case "required_double_array_string_date-time": - requiredBitSet[7] |= 1 << 4 + requiredBitSet[8] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringDateMinusTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21414,7 +23221,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_date-time\"") } case "required_double_array_string_duration": - requiredBitSet[7] |= 1 << 5 + requiredBitSet[8] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringDuration = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21442,7 +23249,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_duration\"") } case "required_double_array_string_email": - requiredBitSet[7] |= 1 << 6 + requiredBitSet[8] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringEmail = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21470,7 +23277,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_email\"") } case "required_double_array_string_hostname": - requiredBitSet[7] |= 1 << 7 + requiredBitSet[8] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringHostname = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21498,7 +23305,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_hostname\"") } case "required_double_array_string_int32": - requiredBitSet[8] |= 1 << 0 + requiredBitSet[8] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21526,7 +23333,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int32\"") } case "required_double_array_string_int64": - requiredBitSet[8] |= 1 << 1 + requiredBitSet[8] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21554,7 +23361,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int64\"") } case "required_double_array_string_ip": - requiredBitSet[8] |= 1 << 2 + requiredBitSet[9] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringIP = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21582,7 +23389,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ip\"") } case "required_double_array_string_ipv4": - requiredBitSet[8] |= 1 << 3 + requiredBitSet[9] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringIpv4 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21610,7 +23417,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ipv4\"") } case "required_double_array_string_ipv6": - requiredBitSet[8] |= 1 << 4 + requiredBitSet[9] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringIpv6 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21638,7 +23445,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_ipv6\"") } case "required_double_array_string_password": - requiredBitSet[8] |= 1 << 5 + requiredBitSet[9] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringPassword = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21666,7 +23473,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_password\"") } case "required_double_array_string_time": - requiredBitSet[8] |= 1 << 6 + requiredBitSet[9] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21694,7 +23501,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_time\"") } case "required_double_array_string_unix": - requiredBitSet[8] |= 1 << 7 + requiredBitSet[9] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21722,7 +23529,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix\"") } case "required_double_array_string_unix-micro": - requiredBitSet[9] |= 1 << 0 + requiredBitSet[9] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21750,7 +23557,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-micro\"") } case "required_double_array_string_unix-milli": - requiredBitSet[9] |= 1 << 1 + requiredBitSet[9] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21778,7 +23585,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-milli\"") } case "required_double_array_string_unix-nano": - requiredBitSet[9] |= 1 << 2 + requiredBitSet[10] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21806,7 +23613,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-nano\"") } case "required_double_array_string_unix-seconds": - requiredBitSet[9] |= 1 << 3 + requiredBitSet[10] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21834,7 +23641,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_unix-seconds\"") } case "required_double_array_string_uri": - requiredBitSet[9] |= 1 << 4 + requiredBitSet[10] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringURI = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21862,7 +23669,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uri\"") } case "required_double_array_string_uuid": - requiredBitSet[9] |= 1 << 5 + requiredBitSet[10] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUUID = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21890,7 +23697,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uuid\"") } case "required_integer": - requiredBitSet[9] |= 1 << 6 + requiredBitSet[10] |= 1 << 4 if err := func() error { v, err := d.Int() s.RequiredInteger = int(v) @@ -21902,7 +23709,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer\"") } case "required_integer_int32": - requiredBitSet[9] |= 1 << 7 + requiredBitSet[10] |= 1 << 5 if err := func() error { v, err := d.Int32() s.RequiredIntegerInt32 = int32(v) @@ -21914,7 +23721,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int32\"") } case "required_integer_int64": - requiredBitSet[10] |= 1 << 0 + requiredBitSet[10] |= 1 << 6 if err := func() error { v, err := d.Int64() s.RequiredIntegerInt64 = int64(v) @@ -21925,8 +23732,44 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_integer_int64\"") } + case "required_integer_uint": + requiredBitSet[10] |= 1 << 7 + if err := func() error { + v, err := d.UInt() + s.RequiredIntegerUint = uint(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint\"") + } + case "required_integer_uint32": + requiredBitSet[11] |= 1 << 0 + if err := func() error { + v, err := d.UInt32() + s.RequiredIntegerUint32 = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint32\"") + } + case "required_integer_uint64": + requiredBitSet[11] |= 1 << 1 + if err := func() error { + v, err := d.UInt64() + s.RequiredIntegerUint64 = uint64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_integer_uint64\"") + } case "required_integer_unix": - requiredBitSet[10] |= 1 << 1 + requiredBitSet[11] |= 1 << 2 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnix = v @@ -21938,7 +23781,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix\"") } case "required_integer_unix-micro": - requiredBitSet[10] |= 1 << 2 + requiredBitSet[11] |= 1 << 3 if err := func() error { v, err := json.DecodeUnixMicro(d) s.RequiredIntegerUnixMinusMicro = v @@ -21950,7 +23793,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-micro\"") } case "required_integer_unix-milli": - requiredBitSet[10] |= 1 << 3 + requiredBitSet[11] |= 1 << 4 if err := func() error { v, err := json.DecodeUnixMilli(d) s.RequiredIntegerUnixMinusMilli = v @@ -21962,7 +23805,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-milli\"") } case "required_integer_unix-nano": - requiredBitSet[10] |= 1 << 4 + requiredBitSet[11] |= 1 << 5 if err := func() error { v, err := json.DecodeUnixNano(d) s.RequiredIntegerUnixMinusNano = v @@ -21974,7 +23817,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-nano\"") } case "required_integer_unix-seconds": - requiredBitSet[10] |= 1 << 5 + requiredBitSet[11] |= 1 << 6 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnixMinusSeconds = v @@ -21986,7 +23829,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-seconds\"") } case "required_null": - requiredBitSet[10] |= 1 << 6 + requiredBitSet[11] |= 1 << 7 if err := func() error { if err := d.Null(); err != nil { return err @@ -21996,7 +23839,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_null\"") } case "required_number": - requiredBitSet[10] |= 1 << 7 + requiredBitSet[12] |= 1 << 0 if err := func() error { v, err := d.Float64() s.RequiredNumber = float64(v) @@ -22008,7 +23851,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number\"") } case "required_number_double": - requiredBitSet[11] |= 1 << 0 + requiredBitSet[12] |= 1 << 1 if err := func() error { v, err := d.Float64() s.RequiredNumberDouble = float64(v) @@ -22020,7 +23863,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_double\"") } case "required_number_float": - requiredBitSet[11] |= 1 << 1 + requiredBitSet[12] |= 1 << 2 if err := func() error { v, err := d.Float32() s.RequiredNumberFloat = float32(v) @@ -22032,7 +23875,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_float\"") } case "required_number_int32": - requiredBitSet[11] |= 1 << 2 + requiredBitSet[12] |= 1 << 3 if err := func() error { v, err := d.Int32() s.RequiredNumberInt32 = int32(v) @@ -22044,7 +23887,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int32\"") } case "required_number_int64": - requiredBitSet[11] |= 1 << 3 + requiredBitSet[12] |= 1 << 4 if err := func() error { v, err := d.Int64() s.RequiredNumberInt64 = int64(v) @@ -22056,7 +23899,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int64\"") } case "required_string": - requiredBitSet[11] |= 1 << 4 + requiredBitSet[12] |= 1 << 5 if err := func() error { v, err := d.Str() s.RequiredString = string(v) @@ -22068,7 +23911,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string\"") } case "required_string_binary": - requiredBitSet[11] |= 1 << 5 + requiredBitSet[12] |= 1 << 6 if err := func() error { v, err := d.Str() s.RequiredStringBinary = string(v) @@ -22080,7 +23923,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_binary\"") } case "required_string_byte": - requiredBitSet[11] |= 1 << 6 + requiredBitSet[12] |= 1 << 7 if err := func() error { v, err := d.Base64() s.RequiredStringByte = []byte(v) @@ -22092,7 +23935,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_byte\"") } case "required_string_date": - requiredBitSet[11] |= 1 << 7 + requiredBitSet[13] |= 1 << 0 if err := func() error { v, err := json.DecodeDate(d) s.RequiredStringDate = v @@ -22104,7 +23947,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date\"") } case "required_string_date-time": - requiredBitSet[12] |= 1 << 0 + requiredBitSet[13] |= 1 << 1 if err := func() error { v, err := json.DecodeDateTime(d) s.RequiredStringDateMinusTime = v @@ -22116,7 +23959,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date-time\"") } case "required_string_duration": - requiredBitSet[12] |= 1 << 1 + requiredBitSet[13] |= 1 << 2 if err := func() error { v, err := json.DecodeDuration(d) s.RequiredStringDuration = v @@ -22128,7 +23971,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_duration\"") } case "required_string_email": - requiredBitSet[12] |= 1 << 2 + requiredBitSet[13] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringEmail = string(v) @@ -22140,7 +23983,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_email\"") } case "required_string_hostname": - requiredBitSet[12] |= 1 << 3 + requiredBitSet[13] |= 1 << 4 if err := func() error { v, err := d.Str() s.RequiredStringHostname = string(v) @@ -22152,7 +23995,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_hostname\"") } case "required_string_int32": - requiredBitSet[12] |= 1 << 4 + requiredBitSet[13] |= 1 << 5 if err := func() error { v, err := json.DecodeStringInt32(d) s.RequiredStringInt32 = v @@ -22164,7 +24007,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int32\"") } case "required_string_int64": - requiredBitSet[12] |= 1 << 5 + requiredBitSet[13] |= 1 << 6 if err := func() error { v, err := json.DecodeStringInt64(d) s.RequiredStringInt64 = v @@ -22176,7 +24019,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int64\"") } case "required_string_ip": - requiredBitSet[12] |= 1 << 6 + requiredBitSet[13] |= 1 << 7 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIP = v @@ -22188,7 +24031,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ip\"") } case "required_string_ipv4": - requiredBitSet[12] |= 1 << 7 + requiredBitSet[14] |= 1 << 0 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIpv4 = v @@ -22200,7 +24043,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv4\"") } case "required_string_ipv6": - requiredBitSet[13] |= 1 << 0 + requiredBitSet[14] |= 1 << 1 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIpv6 = v @@ -22212,7 +24055,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv6\"") } case "required_string_password": - requiredBitSet[13] |= 1 << 1 + requiredBitSet[14] |= 1 << 2 if err := func() error { v, err := d.Str() s.RequiredStringPassword = string(v) @@ -22224,7 +24067,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_password\"") } case "required_string_time": - requiredBitSet[13] |= 1 << 2 + requiredBitSet[14] |= 1 << 3 if err := func() error { v, err := json.DecodeTime(d) s.RequiredStringTime = v @@ -22236,7 +24079,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_time\"") } case "required_string_unix": - requiredBitSet[13] |= 1 << 3 + requiredBitSet[14] |= 1 << 4 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnix = v @@ -22248,7 +24091,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix\"") } case "required_string_unix-micro": - requiredBitSet[13] |= 1 << 4 + requiredBitSet[14] |= 1 << 5 if err := func() error { v, err := json.DecodeStringUnixMicro(d) s.RequiredStringUnixMinusMicro = v @@ -22260,7 +24103,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-micro\"") } case "required_string_unix-milli": - requiredBitSet[13] |= 1 << 5 + requiredBitSet[14] |= 1 << 6 if err := func() error { v, err := json.DecodeStringUnixMilli(d) s.RequiredStringUnixMinusMilli = v @@ -22272,7 +24115,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-milli\"") } case "required_string_unix-nano": - requiredBitSet[13] |= 1 << 6 + requiredBitSet[14] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUnixNano(d) s.RequiredStringUnixMinusNano = v @@ -22284,7 +24127,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-nano\"") } case "required_string_unix-seconds": - requiredBitSet[13] |= 1 << 7 + requiredBitSet[15] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnixMinusSeconds = v @@ -22296,7 +24139,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-seconds\"") } case "required_string_uri": - requiredBitSet[14] |= 1 << 0 + requiredBitSet[15] |= 1 << 1 if err := func() error { v, err := json.DecodeURI(d) s.RequiredStringURI = v @@ -22308,7 +24151,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uri\"") } case "required_string_uuid": - requiredBitSet[14] |= 1 << 1 + requiredBitSet[15] |= 1 << 2 if err := func() error { v, err := json.DecodeUUID(d) s.RequiredStringUUID = v @@ -22425,6 +24268,63 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_array_integer_int64\"") } + case "optional_array_integer_uint": + if err := func() error { + s.OptionalArrayIntegerUint = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint = append(s.OptionalArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint\"") + } + case "optional_array_integer_uint32": + if err := func() error { + s.OptionalArrayIntegerUint32 = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint32 = append(s.OptionalArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint32\"") + } + case "optional_array_integer_uint64": + if err := func() error { + s.OptionalArrayIntegerUint64 = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) + if err != nil { + return err + } + s.OptionalArrayIntegerUint64 = append(s.OptionalArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_integer_uint64\"") + } case "optional_array_integer_unix": if err := func() error { s.OptionalArrayIntegerUnix = make([]time.Time, 0) @@ -23195,6 +25095,87 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_double_array_integer_int64\"") } + case "optional_double_array_integer_uint": + if err := func() error { + s.OptionalDoubleArrayIntegerUint = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint = append(s.OptionalDoubleArrayIntegerUint, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint\"") + } + case "optional_double_array_integer_uint32": + if err := func() error { + s.OptionalDoubleArrayIntegerUint32 = make([][]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint32 + elem = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint32 = append(s.OptionalDoubleArrayIntegerUint32, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint32\"") + } + case "optional_double_array_integer_uint64": + if err := func() error { + s.OptionalDoubleArrayIntegerUint64 = make([][]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint64 + elem = make([]uint64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayIntegerUint64 = append(s.OptionalDoubleArrayIntegerUint64, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_integer_uint64\"") + } case "optional_double_array_integer_unix": if err := func() error { s.OptionalDoubleArrayIntegerUnix = make([][]time.Time, 0) @@ -24114,6 +26095,36 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_integer_int64\"") } + case "optional_integer_uint": + if err := func() error { + s.OptionalIntegerUint.Reset() + if err := s.OptionalIntegerUint.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint\"") + } + case "optional_integer_uint32": + if err := func() error { + s.OptionalIntegerUint32.Reset() + if err := s.OptionalIntegerUint32.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint32\"") + } + case "optional_integer_uint64": + if err := func() error { + s.OptionalIntegerUint64.Reset() + if err := s.OptionalIntegerUint64.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_integer_uint64\"") + } case "optional_integer_unix": if err := func() error { s.OptionalIntegerUnix.Reset() @@ -24454,7 +26465,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [29]uint8{ + for i, mask := range [31]uint8{ 0b11111111, 0b11111111, 0b11111111, @@ -24469,7 +26480,9 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { 0b11111111, 0b11111111, 0b11111111, - 0b00000011, + 0b11111111, + 0b00000111, + 0b00000000, 0b00000000, 0b00000000, 0b00000000, diff --git a/examples/ex_test_format/oas_parameters_gen.go b/examples/ex_test_format/oas_parameters_gen.go index fe9c8f893..856d54a2d 100644 --- a/examples/ex_test_format/oas_parameters_gen.go +++ b/examples/ex_test_format/oas_parameters_gen.go @@ -26,6 +26,12 @@ type TestQueryParameterParams struct { IntegerInt32Array []int32 IntegerInt64 int64 IntegerInt64Array []int64 + IntegerUint uint + IntegerUint32 uint32 + IntegerUint32Array []uint32 + IntegerUint64 uint64 + IntegerUint64Array []uint64 + IntegerUintArray []uint IntegerUnix time.Time IntegerUnixMicro time.Time IntegerUnixMicroArray []time.Time @@ -117,6 +123,24 @@ func unpackTestQueryParameterParams(packed map[string]any) (params TestQueryPara if v, ok := packed["integer_int64_array"]; ok { params.IntegerInt64Array, _ = v.([]int64) } + if v, ok := packed["integer_uint"]; ok { + params.IntegerUint, _ = v.(uint) + } + if v, ok := packed["integer_uint32"]; ok { + params.IntegerUint32, _ = v.(uint32) + } + if v, ok := packed["integer_uint32_array"]; ok { + params.IntegerUint32Array, _ = v.([]uint32) + } + if v, ok := packed["integer_uint64"]; ok { + params.IntegerUint64, _ = v.(uint64) + } + if v, ok := packed["integer_uint64_array"]; ok { + params.IntegerUint64Array, _ = v.([]uint64) + } + if v, ok := packed["integer_uint_array"]; ok { + params.IntegerUintArray, _ = v.([]uint) + } if v, ok := packed["integer_unix"]; ok { params.IntegerUnix, _ = v.(time.Time) } @@ -614,6 +638,231 @@ func decodeTestQueryParameterParams(args [0]string, r *http.Request) (params Tes return params, errors.Wrap(err, "query") } } + // Decode query: integer_uint. + { + cfg := uri.QueryParameterDecodingConfig{ + Name: "integer_uint", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUint(val) + if err != nil { + return err + } + + params.IntegerUint = c + return nil + }); err != nil { + return params, errors.Wrap(err, "query: integer_uint: parse") + } + } else { + return params, errors.Wrap(err, "query") + } + } + // Decode query: integer_uint32. + { + cfg := uri.QueryParameterDecodingConfig{ + Name: "integer_uint32", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUint32(val) + if err != nil { + return err + } + + params.IntegerUint32 = c + return nil + }); err != nil { + return params, errors.Wrap(err, "query: integer_uint32: parse") + } + } else { + return params, errors.Wrap(err, "query") + } + } + // Decode query: integer_uint32_array. + { + cfg := uri.QueryParameterDecodingConfig{ + Name: "integer_uint32_array", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + return d.DecodeArray(func(d uri.Decoder) error { + var paramsDotIntegerUint32ArrayVal uint32 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUint32(val) + if err != nil { + return err + } + + paramsDotIntegerUint32ArrayVal = c + return nil + }(); err != nil { + return err + } + params.IntegerUint32Array = append(params.IntegerUint32Array, paramsDotIntegerUint32ArrayVal) + return nil + }) + }); err != nil { + return params, errors.Wrap(err, "query: integer_uint32_array: parse") + } + if err := func() error { + if params.IntegerUint32Array == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return params, errors.Wrap(err, "query: integer_uint32_array: invalid") + } + } else { + return params, errors.Wrap(err, "query") + } + } + // Decode query: integer_uint64. + { + cfg := uri.QueryParameterDecodingConfig{ + Name: "integer_uint64", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUint64(val) + if err != nil { + return err + } + + params.IntegerUint64 = c + return nil + }); err != nil { + return params, errors.Wrap(err, "query: integer_uint64: parse") + } + } else { + return params, errors.Wrap(err, "query") + } + } + // Decode query: integer_uint64_array. + { + cfg := uri.QueryParameterDecodingConfig{ + Name: "integer_uint64_array", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + return d.DecodeArray(func(d uri.Decoder) error { + var paramsDotIntegerUint64ArrayVal uint64 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUint64(val) + if err != nil { + return err + } + + paramsDotIntegerUint64ArrayVal = c + return nil + }(); err != nil { + return err + } + params.IntegerUint64Array = append(params.IntegerUint64Array, paramsDotIntegerUint64ArrayVal) + return nil + }) + }); err != nil { + return params, errors.Wrap(err, "query: integer_uint64_array: parse") + } + if err := func() error { + if params.IntegerUint64Array == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return params, errors.Wrap(err, "query: integer_uint64_array: invalid") + } + } else { + return params, errors.Wrap(err, "query") + } + } + // Decode query: integer_uint_array. + { + cfg := uri.QueryParameterDecodingConfig{ + Name: "integer_uint_array", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + return d.DecodeArray(func(d uri.Decoder) error { + var paramsDotIntegerUintArrayVal uint + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToUint(val) + if err != nil { + return err + } + + paramsDotIntegerUintArrayVal = c + return nil + }(); err != nil { + return err + } + params.IntegerUintArray = append(params.IntegerUintArray, paramsDotIntegerUintArrayVal) + return nil + }) + }); err != nil { + return params, errors.Wrap(err, "query: integer_uint_array: parse") + } + if err := func() error { + if params.IntegerUintArray == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return params, errors.Wrap(err, "query: integer_uint_array: invalid") + } + } else { + return params, errors.Wrap(err, "query") + } + } // Decode query: integer_unix. { cfg := uri.QueryParameterDecodingConfig{ diff --git a/examples/ex_test_format/oas_request_decoders_gen.go b/examples/ex_test_format/oas_request_decoders_gen.go index ebc5a9c87..c50cfd964 100644 --- a/examples/ex_test_format/oas_request_decoders_gen.go +++ b/examples/ex_test_format/oas_request_decoders_gen.go @@ -2085,8 +2085,8 @@ func (s *Server) decodeTestRequestIntegerNullableArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestIntegerUnixRequest(r *http.Request, span trace.Span) ( - req OptUnixSeconds, +func (s *Server) decodeTestRequestIntegerUintRequest(r *http.Request, span trace.Span) ( + req OptUint, close func() error, rerr error, ) { @@ -2119,7 +2119,7 @@ func (s *Server) decodeTestRequestIntegerUnixRequest(r *http.Request, span trace return req, close, nil } - var request OptUnixSeconds + var request OptUint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2132,189 +2132,21 @@ func (s *Server) decodeTestRequestIntegerUnixRequest(r *http.Request, span trace d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { - return err - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "decode \"application/json\"") - } - return request, close, nil - default: - return req, close, validate.InvalidContentType(ct) - } -} - -func (s *Server) decodeTestRequestIntegerUnixArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, - close func() error, - rerr error, -) { - var closers []func() error - close = func() error { - var merr error - // Close in reverse order, to match defer behavior. - for i := len(closers) - 1; i >= 0; i-- { - c := closers[i] - merr = multierr.Append(merr, c()) - } - return merr - } - defer func() { - if rerr != nil { - rerr = multierr.Append(rerr, close()) - } - }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } - - ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) - if err != nil { - return req, close, errors.Wrap(err, "parse media type") - } - switch { - case ct == "application/json": - if r.ContentLength == 0 { - return req, close, nil - } - - var request []time.Time - buf, err := io.ReadAll(r.Body) - if err != nil { - return req, close, err - } - - if len(buf) == 0 { - return req, close, nil - } - - d := jx.DecodeBytes(buf) - if err := func() error { - request = make([]time.Time, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixSeconds(d) - elem = v - if err != nil { - return err - } - request = append(request, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "decode \"application/json\"") - } - return request, close, nil - default: - return req, close, validate.InvalidContentType(ct) - } -} - -func (s *Server) decodeTestRequestIntegerUnixArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, - close func() error, - rerr error, -) { - var closers []func() error - close = func() error { - var merr error - // Close in reverse order, to match defer behavior. - for i := len(closers) - 1; i >= 0; i-- { - c := closers[i] - merr = multierr.Append(merr, c()) - } - return merr - } - defer func() { - if rerr != nil { - rerr = multierr.Append(rerr, close()) - } - }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } - - ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) - if err != nil { - return req, close, errors.Wrap(err, "parse media type") - } - switch { - case ct == "application/json": - if r.ContentLength == 0 { - return req, close, nil - } - - var request [][]time.Time - buf, err := io.ReadAll(r.Body) - if err != nil { - return req, close, err - } - - if len(buf) == 0 { - return req, close, nil - } - - d := jx.DecodeBytes(buf) - if err := func() error { - request = make([][]time.Time, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixSeconds(d) - elemElem = v - if err != nil { - return err - } - elem = append(elem, elemElem) - return nil - }); err != nil { - return err - } - request = append(request, elem) - return nil - }); err != nil { + if err := request.Decode(d); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if elem == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestIntegerUnixMicroRequest(r *http.Request, span trace.Span) ( - req OptUnixMicro, +func (s *Server) decodeTestRequestIntegerUint32Request(r *http.Request, span trace.Span) ( + req OptUint32, close func() error, rerr error, ) { @@ -2347,7 +2179,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroRequest(r *http.Request, span return req, close, nil } - var request OptUnixMicro + var request OptUint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2360,7 +2192,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixMicro); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -2373,8 +2205,8 @@ func (s *Server) decodeTestRequestIntegerUnixMicroRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestIntegerUnixMicroArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestIntegerUint32ArrayRequest(r *http.Request, span trace.Span) ( + req []uint32, close func() error, rerr error, ) { @@ -2407,7 +2239,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroArrayRequest(r *http.Request, return req, close, nil } - var request []time.Time + var request []uint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2419,11 +2251,11 @@ func (s *Server) decodeTestRequestIntegerUnixMicroArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixMicro(d) - elem = v + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) if err != nil { return err } @@ -2442,8 +2274,8 @@ func (s *Server) decodeTestRequestIntegerUnixMicroArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestIntegerUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestIntegerUint32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uint32, close func() error, rerr error, ) { @@ -2476,7 +2308,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroArrayArrayRequest(r *http.Requ return req, close, nil } - var request [][]time.Time + var request [][]uint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2488,14 +2320,14 @@ func (s *Server) decodeTestRequestIntegerUnixMicroArrayArrayRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []uint32 + elem = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixMicro(d) - elemElem = v + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) if err != nil { return err } @@ -2541,8 +2373,8 @@ func (s *Server) decodeTestRequestIntegerUnixMicroArrayArrayRequest(r *http.Requ } } -func (s *Server) decodeTestRequestIntegerUnixMicroNullableRequest(r *http.Request, span trace.Span) ( - req OptNilUnixMicro, +func (s *Server) decodeTestRequestIntegerUint32NullableRequest(r *http.Request, span trace.Span) ( + req OptNilUint32, close func() error, rerr error, ) { @@ -2575,7 +2407,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableRequest(r *http.Reques return req, close, nil } - var request OptNilUnixMicro + var request OptNilUint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2588,7 +2420,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixMicro); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -2601,8 +2433,8 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableRequest(r *http.Reques } } -func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixMicro, +func (s *Server) decodeTestRequestIntegerUint32NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUint32, close func() error, rerr error, ) { @@ -2635,7 +2467,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayRequest(r *http.R return req, close, nil } - var request []NilUnixMicro + var request []NilUint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2647,10 +2479,10 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixMicro, 0) + request = make([]NilUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixMicro - if err := elem.Decode(d, json.DecodeUnixMicro); err != nil { + var elem NilUint32 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -2668,8 +2500,8 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixMicro, +func (s *Server) decodeTestRequestIntegerUint32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUint32, close func() error, rerr error, ) { @@ -2702,7 +2534,7 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(r *h return req, close, nil } - var request [][]NilUnixMicro + var request [][]NilUint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2714,13 +2546,13 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(r *h d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixMicro, 0) + request = make([][]NilUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixMicro - elem = make([]NilUnixMicro, 0) + var elem []NilUint32 + elem = make([]NilUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixMicro - if err := elemElem.Decode(d, json.DecodeUnixMicro); err != nil { + var elemElem NilUint32 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -2765,8 +2597,8 @@ func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(r *h } } -func (s *Server) decodeTestRequestIntegerUnixMilliRequest(r *http.Request, span trace.Span) ( - req OptUnixMilli, +func (s *Server) decodeTestRequestIntegerUint64Request(r *http.Request, span trace.Span) ( + req OptUint64, close func() error, rerr error, ) { @@ -2799,7 +2631,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliRequest(r *http.Request, span return req, close, nil } - var request OptUnixMilli + var request OptUint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2812,7 +2644,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixMilli); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -2825,8 +2657,8 @@ func (s *Server) decodeTestRequestIntegerUnixMilliRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestIntegerUnixMilliArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestIntegerUint64ArrayRequest(r *http.Request, span trace.Span) ( + req []uint64, close func() error, rerr error, ) { @@ -2859,7 +2691,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliArrayRequest(r *http.Request, return req, close, nil } - var request []time.Time + var request []uint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2871,11 +2703,11 @@ func (s *Server) decodeTestRequestIntegerUnixMilliArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixMilli(d) - elem = v + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) if err != nil { return err } @@ -2894,8 +2726,8 @@ func (s *Server) decodeTestRequestIntegerUnixMilliArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestIntegerUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestIntegerUint64ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uint64, close func() error, rerr error, ) { @@ -2928,7 +2760,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliArrayArrayRequest(r *http.Requ return req, close, nil } - var request [][]time.Time + var request [][]uint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -2940,14 +2772,14 @@ func (s *Server) decodeTestRequestIntegerUnixMilliArrayArrayRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []uint64 + elem = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixMilli(d) - elemElem = v + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) if err != nil { return err } @@ -2993,8 +2825,8 @@ func (s *Server) decodeTestRequestIntegerUnixMilliArrayArrayRequest(r *http.Requ } } -func (s *Server) decodeTestRequestIntegerUnixMilliNullableRequest(r *http.Request, span trace.Span) ( - req OptNilUnixMilli, +func (s *Server) decodeTestRequestIntegerUint64NullableRequest(r *http.Request, span trace.Span) ( + req OptNilUint64, close func() error, rerr error, ) { @@ -3027,7 +2859,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableRequest(r *http.Reques return req, close, nil } - var request OptNilUnixMilli + var request OptNilUint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3040,7 +2872,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixMilli); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -3053,8 +2885,8 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableRequest(r *http.Reques } } -func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixMilli, +func (s *Server) decodeTestRequestIntegerUint64NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUint64, close func() error, rerr error, ) { @@ -3087,7 +2919,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayRequest(r *http.R return req, close, nil } - var request []NilUnixMilli + var request []NilUint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3099,10 +2931,10 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixMilli, 0) + request = make([]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixMilli - if err := elem.Decode(d, json.DecodeUnixMilli); err != nil { + var elem NilUint64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -3120,8 +2952,8 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixMilli, +func (s *Server) decodeTestRequestIntegerUint64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUint64, close func() error, rerr error, ) { @@ -3154,7 +2986,7 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(r *h return req, close, nil } - var request [][]NilUnixMilli + var request [][]NilUint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3166,13 +2998,13 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(r *h d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixMilli, 0) + request = make([][]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixMilli - elem = make([]NilUnixMilli, 0) + var elem []NilUint64 + elem = make([]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixMilli - if err := elemElem.Decode(d, json.DecodeUnixMilli); err != nil { + var elemElem NilUint64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -3217,8 +3049,8 @@ func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(r *h } } -func (s *Server) decodeTestRequestIntegerUnixNanoRequest(r *http.Request, span trace.Span) ( - req OptUnixNano, +func (s *Server) decodeTestRequestIntegerUintArrayRequest(r *http.Request, span trace.Span) ( + req []uint, close func() error, rerr error, ) { @@ -3251,7 +3083,175 @@ func (s *Server) decodeTestRequestIntegerUnixNanoRequest(r *http.Request, span t return req, close, nil } - var request OptUnixNano + var request []uint + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestIntegerUintArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uint, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]uint + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestIntegerUintNullableRequest(r *http.Request, span trace.Span) ( + req OptNilUint, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request OptNilUint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3264,7 +3264,7 @@ func (s *Server) decodeTestRequestIntegerUnixNanoRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixNano); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -3277,8 +3277,8 @@ func (s *Server) decodeTestRequestIntegerUnixNanoRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestIntegerUnixNanoArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestIntegerUintNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUint, close func() error, rerr error, ) { @@ -3311,7 +3311,7 @@ func (s *Server) decodeTestRequestIntegerUnixNanoArrayRequest(r *http.Request, s return req, close, nil } - var request []time.Time + var request []NilUint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3323,12 +3323,10 @@ func (s *Server) decodeTestRequestIntegerUnixNanoArrayRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixNano(d) - elem = v - if err != nil { + var elem NilUint + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -3346,8 +3344,8 @@ func (s *Server) decodeTestRequestIntegerUnixNanoArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestIntegerUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestIntegerUintNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUint, close func() error, rerr error, ) { @@ -3380,7 +3378,7 @@ func (s *Server) decodeTestRequestIntegerUnixNanoArrayArrayRequest(r *http.Reque return req, close, nil } - var request [][]time.Time + var request [][]NilUint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3392,15 +3390,13 @@ func (s *Server) decodeTestRequestIntegerUnixNanoArrayArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilUint + elem = make([]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixNano(d) - elemElem = v - if err != nil { + var elemElem NilUint + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -3445,8 +3441,8 @@ func (s *Server) decodeTestRequestIntegerUnixNanoArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestIntegerUnixNanoNullableRequest(r *http.Request, span trace.Span) ( - req OptNilUnixNano, +func (s *Server) decodeTestRequestIntegerUnixRequest(r *http.Request, span trace.Span) ( + req OptUnixSeconds, close func() error, rerr error, ) { @@ -3479,7 +3475,7 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableRequest(r *http.Request return req, close, nil } - var request OptNilUnixNano + var request OptUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3492,7 +3488,7 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixNano); err != nil { + if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { return err } return nil @@ -3505,8 +3501,8 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableRequest(r *http.Request } } -func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixNano, +func (s *Server) decodeTestRequestIntegerUnixArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -3539,7 +3535,7 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayRequest(r *http.Re return req, close, nil } - var request []NilUnixNano + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3551,10 +3547,12 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixNano, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixNano - if err := elem.Decode(d, json.DecodeUnixNano); err != nil { + var elem time.Time + v, err := json.DecodeUnixSeconds(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -3572,8 +3570,8 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixNano, +func (s *Server) decodeTestRequestIntegerUnixArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -3606,7 +3604,7 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(r *ht return req, close, nil } - var request [][]NilUnixNano + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3618,13 +3616,15 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixNano, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixNano - elem = make([]NilUnixNano, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixNano - if err := elemElem.Decode(d, json.DecodeUnixNano); err != nil { + var elemElem time.Time + v, err := json.DecodeUnixSeconds(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -3669,8 +3669,8 @@ func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestIntegerUnixNullableRequest(r *http.Request, span trace.Span) ( - req OptNilUnixSeconds, +func (s *Server) decodeTestRequestIntegerUnixMicroRequest(r *http.Request, span trace.Span) ( + req OptUnixMicro, close func() error, rerr error, ) { @@ -3703,7 +3703,7 @@ func (s *Server) decodeTestRequestIntegerUnixNullableRequest(r *http.Request, sp return req, close, nil } - var request OptNilUnixSeconds + var request OptUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3716,7 +3716,7 @@ func (s *Server) decodeTestRequestIntegerUnixNullableRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { + if err := request.Decode(d, json.DecodeUnixMicro); err != nil { return err } return nil @@ -3729,8 +3729,8 @@ func (s *Server) decodeTestRequestIntegerUnixNullableRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestIntegerUnixNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixSeconds, +func (s *Server) decodeTestRequestIntegerUnixMicroArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -3763,7 +3763,7 @@ func (s *Server) decodeTestRequestIntegerUnixNullableArrayRequest(r *http.Reques return req, close, nil } - var request []NilUnixSeconds + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3775,10 +3775,12 @@ func (s *Server) decodeTestRequestIntegerUnixNullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixSeconds, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixSeconds - if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elem time.Time + v, err := json.DecodeUnixMicro(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -3796,8 +3798,8 @@ func (s *Server) decodeTestRequestIntegerUnixNullableArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestIntegerUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixSeconds, +func (s *Server) decodeTestRequestIntegerUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -3830,7 +3832,7 @@ func (s *Server) decodeTestRequestIntegerUnixNullableArrayArrayRequest(r *http.R return req, close, nil } - var request [][]NilUnixSeconds + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3842,13 +3844,15 @@ func (s *Server) decodeTestRequestIntegerUnixNullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixSeconds, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixSeconds - elem = make([]NilUnixSeconds, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixSeconds - if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elemElem time.Time + v, err := json.DecodeUnixMicro(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -3893,8 +3897,8 @@ func (s *Server) decodeTestRequestIntegerUnixNullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestIntegerUnixSecondsRequest(r *http.Request, span trace.Span) ( - req OptUnixSeconds, +func (s *Server) decodeTestRequestIntegerUnixMicroNullableRequest(r *http.Request, span trace.Span) ( + req OptNilUnixMicro, close func() error, rerr error, ) { @@ -3927,7 +3931,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsRequest(r *http.Request, spa return req, close, nil } - var request OptUnixSeconds + var request OptNilUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3940,7 +3944,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { + if err := request.Decode(d, json.DecodeUnixMicro); err != nil { return err } return nil @@ -3953,8 +3957,8 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestIntegerUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixMicro, close func() error, rerr error, ) { @@ -3987,7 +3991,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsArrayRequest(r *http.Request return req, close, nil } - var request []time.Time + var request []NilUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -3999,12 +4003,10 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixSeconds(d) - elem = v - if err != nil { + var elem NilUnixMicro + if err := elem.Decode(d, json.DecodeUnixMicro); err != nil { return err } request = append(request, elem) @@ -4022,8 +4024,8 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestIntegerUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestIntegerUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixMicro, close func() error, rerr error, ) { @@ -4056,7 +4058,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsArrayArrayRequest(r *http.Re return req, close, nil } - var request [][]time.Time + var request [][]NilUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4068,15 +4070,13 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilUnixMicro + elem = make([]NilUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixSeconds(d) - elemElem = v - if err != nil { + var elemElem NilUnixMicro + if err := elemElem.Decode(d, json.DecodeUnixMicro); err != nil { return err } elem = append(elem, elemElem) @@ -4121,8 +4121,8 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestIntegerUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( - req OptNilUnixSeconds, +func (s *Server) decodeTestRequestIntegerUnixMilliRequest(r *http.Request, span trace.Span) ( + req OptUnixMilli, close func() error, rerr error, ) { @@ -4155,7 +4155,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableRequest(r *http.Requ return req, close, nil } - var request OptNilUnixSeconds + var request OptUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4168,7 +4168,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { + if err := request.Decode(d, json.DecodeUnixMilli); err != nil { return err } return nil @@ -4181,8 +4181,8 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixSeconds, +func (s *Server) decodeTestRequestIntegerUnixMilliArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -4215,7 +4215,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayRequest(r *http return req, close, nil } - var request []NilUnixSeconds + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4227,10 +4227,12 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixSeconds, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixSeconds - if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elem time.Time + v, err := json.DecodeUnixMilli(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -4248,8 +4250,8 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixSeconds, +func (s *Server) decodeTestRequestIntegerUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -4282,7 +4284,7 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(r return req, close, nil } - var request [][]NilUnixSeconds + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4294,13 +4296,15 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixSeconds, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixSeconds - elem = make([]NilUnixSeconds, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixSeconds - if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elemElem time.Time + v, err := json.DecodeUnixMilli(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -4345,8 +4349,8 @@ func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestNullRequest(r *http.Request, span trace.Span) ( - req OptNull, +func (s *Server) decodeTestRequestIntegerUnixMilliNullableRequest(r *http.Request, span trace.Span) ( + req OptNilUnixMilli, close func() error, rerr error, ) { @@ -4379,7 +4383,7 @@ func (s *Server) decodeTestRequestNullRequest(r *http.Request, span trace.Span) return req, close, nil } - var request OptNull + var request OptNilUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4392,7 +4396,7 @@ func (s *Server) decodeTestRequestNullRequest(r *http.Request, span trace.Span) d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeUnixMilli); err != nil { return err } return nil @@ -4405,8 +4409,8 @@ func (s *Server) decodeTestRequestNullRequest(r *http.Request, span trace.Span) } } -func (s *Server) decodeTestRequestNullArrayRequest(r *http.Request, span trace.Span) ( - req []struct{}, +func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixMilli, close func() error, rerr error, ) { @@ -4439,7 +4443,7 @@ func (s *Server) decodeTestRequestNullArrayRequest(r *http.Request, span trace.S return req, close, nil } - var request []struct{} + var request []NilUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4451,10 +4455,10 @@ func (s *Server) decodeTestRequestNullArrayRequest(r *http.Request, span trace.S d := jx.DecodeBytes(buf) if err := func() error { - request = make([]struct{}, 0) + request = make([]NilUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem struct{} - if err := d.Null(); err != nil { + var elem NilUnixMilli + if err := elem.Decode(d, json.DecodeUnixMilli); err != nil { return err } request = append(request, elem) @@ -4472,8 +4476,8 @@ func (s *Server) decodeTestRequestNullArrayRequest(r *http.Request, span trace.S } } -func (s *Server) decodeTestRequestNullArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]struct{}, +func (s *Server) decodeTestRequestIntegerUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixMilli, close func() error, rerr error, ) { @@ -4506,7 +4510,7 @@ func (s *Server) decodeTestRequestNullArrayArrayRequest(r *http.Request, span tr return req, close, nil } - var request [][]struct{} + var request [][]NilUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4518,13 +4522,13 @@ func (s *Server) decodeTestRequestNullArrayArrayRequest(r *http.Request, span tr d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]struct{}, 0) + request = make([][]NilUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []struct{} - elem = make([]struct{}, 0) + var elem []NilUnixMilli + elem = make([]NilUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem struct{} - if err := d.Null(); err != nil { + var elemElem NilUnixMilli + if err := elemElem.Decode(d, json.DecodeUnixMilli); err != nil { return err } elem = append(elem, elemElem) @@ -4569,8 +4573,8 @@ func (s *Server) decodeTestRequestNullArrayArrayRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestNullNullableRequest(r *http.Request, span trace.Span) ( - req OptNull, +func (s *Server) decodeTestRequestIntegerUnixNanoRequest(r *http.Request, span trace.Span) ( + req OptUnixNano, close func() error, rerr error, ) { @@ -4603,7 +4607,7 @@ func (s *Server) decodeTestRequestNullNullableRequest(r *http.Request, span trac return req, close, nil } - var request OptNull + var request OptUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4616,7 +4620,7 @@ func (s *Server) decodeTestRequestNullNullableRequest(r *http.Request, span trac d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeUnixNano); err != nil { return err } return nil @@ -4629,8 +4633,8 @@ func (s *Server) decodeTestRequestNullNullableRequest(r *http.Request, span trac } } -func (s *Server) decodeTestRequestNullNullableArrayRequest(r *http.Request, span trace.Span) ( - req []struct{}, +func (s *Server) decodeTestRequestIntegerUnixNanoArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -4663,7 +4667,7 @@ func (s *Server) decodeTestRequestNullNullableArrayRequest(r *http.Request, span return req, close, nil } - var request []struct{} + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4675,10 +4679,12 @@ func (s *Server) decodeTestRequestNullNullableArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]struct{}, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem struct{} - if err := d.Null(); err != nil { + var elem time.Time + v, err := json.DecodeUnixNano(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -4696,8 +4702,8 @@ func (s *Server) decodeTestRequestNullNullableArrayRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestNullNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]struct{}, +func (s *Server) decodeTestRequestIntegerUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -4730,7 +4736,7 @@ func (s *Server) decodeTestRequestNullNullableArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]struct{} + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4742,13 +4748,15 @@ func (s *Server) decodeTestRequestNullNullableArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]struct{}, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []struct{} - elem = make([]struct{}, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem struct{} - if err := d.Null(); err != nil { + var elemElem time.Time + v, err := json.DecodeUnixNano(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -4793,8 +4801,8 @@ func (s *Server) decodeTestRequestNullNullableArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestNumberRequest(r *http.Request, span trace.Span) ( - req OptFloat64, +func (s *Server) decodeTestRequestIntegerUnixNanoNullableRequest(r *http.Request, span trace.Span) ( + req OptNilUnixNano, close func() error, rerr error, ) { @@ -4827,7 +4835,7 @@ func (s *Server) decodeTestRequestNumberRequest(r *http.Request, span trace.Span return req, close, nil } - var request OptFloat64 + var request OptNilUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4840,27 +4848,79 @@ func (s *Server) decodeTestRequestNumberRequest(r *http.Request, span trace.Span d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeUnixNano); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixNano, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []NilUnixNano + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { + request = make([]NilUnixNano, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilUnixNano + if err := elem.Decode(d, json.DecodeUnixNano); err != nil { return err } + request = append(request, elem) + return nil + }); err != nil { + return err } return nil }(); err != nil { - return req, close, errors.Wrap(err, "validate") + return req, close, errors.Wrap(err, "decode \"application/json\"") } return request, close, nil default: @@ -4868,8 +4928,8 @@ func (s *Server) decodeTestRequestNumberRequest(r *http.Request, span trace.Span } } -func (s *Server) decodeTestRequestNumberArrayRequest(r *http.Request, span trace.Span) ( - req []float64, +func (s *Server) decodeTestRequestIntegerUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixNano, close func() error, rerr error, ) { @@ -4902,7 +4962,7 @@ func (s *Server) decodeTestRequestNumberArrayRequest(r *http.Request, span trace return req, close, nil } - var request []float64 + var request [][]NilUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -4914,12 +4974,18 @@ func (s *Server) decodeTestRequestNumberArrayRequest(r *http.Request, span trace d := jx.DecodeBytes(buf) if err := func() error { - request = make([]float64, 0) + request = make([][]NilUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem float64 - v, err := d.Float64() - elem = float64(v) - if err != nil { + var elem []NilUnixNano + elem = make([]NilUnixNano, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilUnixNano + if err := elemElem.Decode(d, json.DecodeUnixNano); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { return err } request = append(request, elem) @@ -4935,8 +5001,8 @@ func (s *Server) decodeTestRequestNumberArrayRequest(r *http.Request, span trace var failures []validate.FieldError for i, elem := range request { if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") + if elem == nil { + return errors.New("nil is invalid value") } return nil }(); err != nil { @@ -4959,8 +5025,8 @@ func (s *Server) decodeTestRequestNumberArrayRequest(r *http.Request, span trace } } -func (s *Server) decodeTestRequestNumberArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]float64, +func (s *Server) decodeTestRequestIntegerUnixNullableRequest(r *http.Request, span trace.Span) ( + req OptNilUnixSeconds, close func() error, rerr error, ) { @@ -4993,7 +5059,7 @@ func (s *Server) decodeTestRequestNumberArrayArrayRequest(r *http.Request, span return req, close, nil } - var request [][]float64 + var request OptNilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5005,15 +5071,140 @@ func (s *Server) decodeTestRequestNumberArrayArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]float64, 0) + request.Reset() + if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestIntegerUnixNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []NilUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []float64 - elem = make([]float64, 0) + var elem NilUnixSeconds + if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestIntegerUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]NilUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilUnixSeconds, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilUnixSeconds + elem = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem float64 - v, err := d.Float64() - elemElem = float64(v) - if err != nil { + var elemElem NilUnixSeconds + if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { return err } elem = append(elem, elemElem) @@ -5037,23 +5228,6 @@ func (s *Server) decodeTestRequestNumberArrayArrayRequest(r *http.Request, span if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -5075,8 +5249,8 @@ func (s *Server) decodeTestRequestNumberArrayArrayRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestNumberDoubleRequest(r *http.Request, span trace.Span) ( - req OptFloat64, +func (s *Server) decodeTestRequestIntegerUnixSecondsRequest(r *http.Request, span trace.Span) ( + req OptUnixSeconds, close func() error, rerr error, ) { @@ -5109,7 +5283,7 @@ func (s *Server) decodeTestRequestNumberDoubleRequest(r *http.Request, span trac return req, close, nil } - var request OptFloat64 + var request OptUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5122,36 +5296,21 @@ func (s *Server) decodeTestRequestNumberDoubleRequest(r *http.Request, span trac d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberDoubleArrayRequest(r *http.Request, span trace.Span) ( - req []float64, +func (s *Server) decodeTestRequestIntegerUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -5184,7 +5343,7 @@ func (s *Server) decodeTestRequestNumberDoubleArrayRequest(r *http.Request, span return req, close, nil } - var request []float64 + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5196,11 +5355,11 @@ func (s *Server) decodeTestRequestNumberDoubleArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]float64, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem float64 - v, err := d.Float64() - elem = float64(v) + var elem time.Time + v, err := json.DecodeUnixSeconds(d) + elem = v if err != nil { return err } @@ -5213,36 +5372,14 @@ func (s *Server) decodeTestRequestNumberDoubleArrayRequest(r *http.Request, span }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberDoubleArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]float64, +func (s *Server) decodeTestRequestIntegerUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -5275,7 +5412,7 @@ func (s *Server) decodeTestRequestNumberDoubleArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]float64 + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5287,14 +5424,14 @@ func (s *Server) decodeTestRequestNumberDoubleArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]float64, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []float64 - elem = make([]float64, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem float64 - v, err := d.Float64() - elemElem = float64(v) + var elemElem time.Time + v, err := json.DecodeUnixSeconds(d) + elemElem = v if err != nil { return err } @@ -5319,23 +5456,6 @@ func (s *Server) decodeTestRequestNumberDoubleArrayArrayRequest(r *http.Request, if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -5357,8 +5477,8 @@ func (s *Server) decodeTestRequestNumberDoubleArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestNumberDoubleNullableRequest(r *http.Request, span trace.Span) ( - req OptNilFloat64, +func (s *Server) decodeTestRequestIntegerUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( + req OptNilUnixSeconds, close func() error, rerr error, ) { @@ -5391,7 +5511,7 @@ func (s *Server) decodeTestRequestNumberDoubleNullableRequest(r *http.Request, s return req, close, nil } - var request OptNilFloat64 + var request OptNilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5404,36 +5524,21 @@ func (s *Server) decodeTestRequestNumberDoubleNullableRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberDoubleNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilFloat64, +func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixSeconds, close func() error, rerr error, ) { @@ -5466,7 +5571,7 @@ func (s *Server) decodeTestRequestNumberDoubleNullableArrayRequest(r *http.Reque return req, close, nil } - var request []NilFloat64 + var request []NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5478,10 +5583,10 @@ func (s *Server) decodeTestRequestNumberDoubleNullableArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilFloat64, 0) + request = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilFloat64 - if err := elem.Decode(d); err != nil { + var elem NilUnixSeconds + if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { return err } request = append(request, elem) @@ -5493,36 +5598,14 @@ func (s *Server) decodeTestRequestNumberDoubleNullableArrayRequest(r *http.Reque }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberDoubleNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilFloat64, +func (s *Server) decodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixSeconds, close func() error, rerr error, ) { @@ -5555,7 +5638,7 @@ func (s *Server) decodeTestRequestNumberDoubleNullableArrayArrayRequest(r *http. return req, close, nil } - var request [][]NilFloat64 + var request [][]NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5567,13 +5650,13 @@ func (s *Server) decodeTestRequestNumberDoubleNullableArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilFloat64, 0) + request = make([][]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilFloat64 - elem = make([]NilFloat64, 0) + var elem []NilUnixSeconds + elem = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilFloat64 - if err := elemElem.Decode(d); err != nil { + var elemElem NilUnixSeconds + if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { return err } elem = append(elem, elemElem) @@ -5597,23 +5680,6 @@ func (s *Server) decodeTestRequestNumberDoubleNullableArrayArrayRequest(r *http. if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -5635,8 +5701,8 @@ func (s *Server) decodeTestRequestNumberDoubleNullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestNumberFloatRequest(r *http.Request, span trace.Span) ( - req OptFloat32, +func (s *Server) decodeTestRequestNullRequest(r *http.Request, span trace.Span) ( + req OptNull, close func() error, rerr error, ) { @@ -5669,7 +5735,7 @@ func (s *Server) decodeTestRequestNumberFloatRequest(r *http.Request, span trace return req, close, nil } - var request OptFloat32 + var request OptNull buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5689,29 +5755,14 @@ func (s *Server) decodeTestRequestNumberFloatRequest(r *http.Request, span trace }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberFloatArrayRequest(r *http.Request, span trace.Span) ( - req []float32, +func (s *Server) decodeTestRequestNullArrayRequest(r *http.Request, span trace.Span) ( + req []struct{}, close func() error, rerr error, ) { @@ -5744,7 +5795,7 @@ func (s *Server) decodeTestRequestNumberFloatArrayRequest(r *http.Request, span return req, close, nil } - var request []float32 + var request []struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5756,12 +5807,10 @@ func (s *Server) decodeTestRequestNumberFloatArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]float32, 0) + request = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem float32 - v, err := d.Float32() - elem = float32(v) - if err != nil { + var elem struct{} + if err := d.Null(); err != nil { return err } request = append(request, elem) @@ -5773,36 +5822,14 @@ func (s *Server) decodeTestRequestNumberFloatArrayRequest(r *http.Request, span }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberFloatArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]float32, +func (s *Server) decodeTestRequestNullArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]struct{}, close func() error, rerr error, ) { @@ -5835,7 +5862,7 @@ func (s *Server) decodeTestRequestNumberFloatArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]float32 + var request [][]struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5847,15 +5874,13 @@ func (s *Server) decodeTestRequestNumberFloatArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]float32, 0) + request = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []float32 - elem = make([]float32, 0) + var elem []struct{} + elem = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem float32 - v, err := d.Float32() - elemElem = float32(v) - if err != nil { + var elemElem struct{} + if err := d.Null(); err != nil { return err } elem = append(elem, elemElem) @@ -5879,23 +5904,6 @@ func (s *Server) decodeTestRequestNumberFloatArrayArrayRequest(r *http.Request, if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -5917,8 +5925,8 @@ func (s *Server) decodeTestRequestNumberFloatArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestNumberFloatNullableRequest(r *http.Request, span trace.Span) ( - req OptNilFloat32, +func (s *Server) decodeTestRequestNullNullableRequest(r *http.Request, span trace.Span) ( + req OptNull, close func() error, rerr error, ) { @@ -5951,7 +5959,7 @@ func (s *Server) decodeTestRequestNumberFloatNullableRequest(r *http.Request, sp return req, close, nil } - var request OptNilFloat32 + var request OptNull buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -5971,29 +5979,14 @@ func (s *Server) decodeTestRequestNumberFloatNullableRequest(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberFloatNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilFloat32, +func (s *Server) decodeTestRequestNullNullableArrayRequest(r *http.Request, span trace.Span) ( + req []struct{}, close func() error, rerr error, ) { @@ -6026,7 +6019,7 @@ func (s *Server) decodeTestRequestNumberFloatNullableArrayRequest(r *http.Reques return req, close, nil } - var request []NilFloat32 + var request []struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6038,10 +6031,10 @@ func (s *Server) decodeTestRequestNumberFloatNullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilFloat32, 0) + request = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilFloat32 - if err := elem.Decode(d); err != nil { + var elem struct{} + if err := d.Null(); err != nil { return err } request = append(request, elem) @@ -6053,36 +6046,14 @@ func (s *Server) decodeTestRequestNumberFloatNullableArrayRequest(r *http.Reques }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberFloatNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilFloat32, +func (s *Server) decodeTestRequestNullNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]struct{}, close func() error, rerr error, ) { @@ -6115,7 +6086,7 @@ func (s *Server) decodeTestRequestNumberFloatNullableArrayArrayRequest(r *http.R return req, close, nil } - var request [][]NilFloat32 + var request [][]struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6127,13 +6098,13 @@ func (s *Server) decodeTestRequestNumberFloatNullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilFloat32, 0) + request = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilFloat32 - elem = make([]NilFloat32, 0) + var elem []struct{} + elem = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilFloat32 - if err := elemElem.Decode(d); err != nil { + var elemElem struct{} + if err := d.Null(); err != nil { return err } elem = append(elem, elemElem) @@ -6157,23 +6128,6 @@ func (s *Server) decodeTestRequestNumberFloatNullableArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6195,8 +6149,8 @@ func (s *Server) decodeTestRequestNumberFloatNullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestNumberInt32Request(r *http.Request, span trace.Span) ( - req OptInt32, +func (s *Server) decodeTestRequestNumberRequest(r *http.Request, span trace.Span) ( + req OptFloat64, close func() error, rerr error, ) { @@ -6229,7 +6183,7 @@ func (s *Server) decodeTestRequestNumberInt32Request(r *http.Request, span trace return req, close, nil } - var request OptInt32 + var request OptFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6249,14 +6203,29 @@ func (s *Server) decodeTestRequestNumberInt32Request(r *http.Request, span trace }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt32ArrayRequest(r *http.Request, span trace.Span) ( - req []int32, +func (s *Server) decodeTestRequestNumberArrayRequest(r *http.Request, span trace.Span) ( + req []float64, close func() error, rerr error, ) { @@ -6289,7 +6258,7 @@ func (s *Server) decodeTestRequestNumberInt32ArrayRequest(r *http.Request, span return req, close, nil } - var request []int32 + var request []float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6301,11 +6270,11 @@ func (s *Server) decodeTestRequestNumberInt32ArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int32, 0) + request = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int32 - v, err := d.Int32() - elem = int32(v) + var elem float64 + v, err := d.Float64() + elem = float64(v) if err != nil { return err } @@ -6318,14 +6287,36 @@ func (s *Server) decodeTestRequestNumberInt32ArrayRequest(r *http.Request, span }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int32, +func (s *Server) decodeTestRequestNumberArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]float64, close func() error, rerr error, ) { @@ -6358,7 +6349,7 @@ func (s *Server) decodeTestRequestNumberInt32ArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]int32 + var request [][]float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6370,14 +6361,14 @@ func (s *Server) decodeTestRequestNumberInt32ArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int32, 0) + request = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int32 - elem = make([]int32, 0) + var elem []float64 + elem = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int32 - v, err := d.Int32() - elemElem = int32(v) + var elemElem float64 + v, err := d.Float64() + elemElem = float64(v) if err != nil { return err } @@ -6402,6 +6393,23 @@ func (s *Server) decodeTestRequestNumberInt32ArrayArrayRequest(r *http.Request, if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6423,8 +6431,8 @@ func (s *Server) decodeTestRequestNumberInt32ArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestNumberInt32NullableRequest(r *http.Request, span trace.Span) ( - req OptNilInt32, +func (s *Server) decodeTestRequestNumberDoubleRequest(r *http.Request, span trace.Span) ( + req OptFloat64, close func() error, rerr error, ) { @@ -6457,7 +6465,7 @@ func (s *Server) decodeTestRequestNumberInt32NullableRequest(r *http.Request, sp return req, close, nil } - var request OptNilInt32 + var request OptFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6477,14 +6485,29 @@ func (s *Server) decodeTestRequestNumberInt32NullableRequest(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt32NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilInt32, +func (s *Server) decodeTestRequestNumberDoubleArrayRequest(r *http.Request, span trace.Span) ( + req []float64, close func() error, rerr error, ) { @@ -6517,7 +6540,7 @@ func (s *Server) decodeTestRequestNumberInt32NullableArrayRequest(r *http.Reques return req, close, nil } - var request []NilInt32 + var request []float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6529,10 +6552,12 @@ func (s *Server) decodeTestRequestNumberInt32NullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilInt32, 0) + request = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt32 - if err := elem.Decode(d); err != nil { + var elem float64 + v, err := d.Float64() + elem = float64(v) + if err != nil { return err } request = append(request, elem) @@ -6544,14 +6569,36 @@ func (s *Server) decodeTestRequestNumberInt32NullableArrayRequest(r *http.Reques }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilInt32, +func (s *Server) decodeTestRequestNumberDoubleArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]float64, close func() error, rerr error, ) { @@ -6584,7 +6631,7 @@ func (s *Server) decodeTestRequestNumberInt32NullableArrayArrayRequest(r *http.R return req, close, nil } - var request [][]NilInt32 + var request [][]float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6596,13 +6643,15 @@ func (s *Server) decodeTestRequestNumberInt32NullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilInt32, 0) + request = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt32 - elem = make([]NilInt32, 0) + var elem []float64 + elem = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt32 - if err := elemElem.Decode(d); err != nil { + var elemElem float64 + v, err := d.Float64() + elemElem = float64(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -6626,6 +6675,23 @@ func (s *Server) decodeTestRequestNumberInt32NullableArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6647,8 +6713,8 @@ func (s *Server) decodeTestRequestNumberInt32NullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestNumberInt64Request(r *http.Request, span trace.Span) ( - req OptInt64, +func (s *Server) decodeTestRequestNumberDoubleNullableRequest(r *http.Request, span trace.Span) ( + req OptNilFloat64, close func() error, rerr error, ) { @@ -6681,7 +6747,7 @@ func (s *Server) decodeTestRequestNumberInt64Request(r *http.Request, span trace return req, close, nil } - var request OptInt64 + var request OptNilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6701,14 +6767,29 @@ func (s *Server) decodeTestRequestNumberInt64Request(r *http.Request, span trace }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt64ArrayRequest(r *http.Request, span trace.Span) ( - req []int64, +func (s *Server) decodeTestRequestNumberDoubleNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilFloat64, close func() error, rerr error, ) { @@ -6741,7 +6822,7 @@ func (s *Server) decodeTestRequestNumberInt64ArrayRequest(r *http.Request, span return req, close, nil } - var request []int64 + var request []NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6753,12 +6834,10 @@ func (s *Server) decodeTestRequestNumberInt64ArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int64, 0) + request = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int64 - v, err := d.Int64() - elem = int64(v) - if err != nil { + var elem NilFloat64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -6770,14 +6849,36 @@ func (s *Server) decodeTestRequestNumberInt64ArrayRequest(r *http.Request, span }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int64, +func (s *Server) decodeTestRequestNumberDoubleNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilFloat64, close func() error, rerr error, ) { @@ -6810,7 +6911,7 @@ func (s *Server) decodeTestRequestNumberInt64ArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]int64 + var request [][]NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6822,15 +6923,13 @@ func (s *Server) decodeTestRequestNumberInt64ArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int64, 0) + request = make([][]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int64 - elem = make([]int64, 0) + var elem []NilFloat64 + elem = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int64 - v, err := d.Int64() - elemElem = int64(v) - if err != nil { + var elemElem NilFloat64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -6854,6 +6953,23 @@ func (s *Server) decodeTestRequestNumberInt64ArrayArrayRequest(r *http.Request, if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -6875,8 +6991,8 @@ func (s *Server) decodeTestRequestNumberInt64ArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestNumberInt64NullableRequest(r *http.Request, span trace.Span) ( - req OptNilInt64, +func (s *Server) decodeTestRequestNumberFloatRequest(r *http.Request, span trace.Span) ( + req OptFloat32, close func() error, rerr error, ) { @@ -6909,7 +7025,7 @@ func (s *Server) decodeTestRequestNumberInt64NullableRequest(r *http.Request, sp return req, close, nil } - var request OptNilInt64 + var request OptFloat32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6929,14 +7045,29 @@ func (s *Server) decodeTestRequestNumberInt64NullableRequest(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt64NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilInt64, +func (s *Server) decodeTestRequestNumberFloatArrayRequest(r *http.Request, span trace.Span) ( + req []float32, close func() error, rerr error, ) { @@ -6969,7 +7100,7 @@ func (s *Server) decodeTestRequestNumberInt64NullableArrayRequest(r *http.Reques return req, close, nil } - var request []NilInt64 + var request []float32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -6981,10 +7112,12 @@ func (s *Server) decodeTestRequestNumberInt64NullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilInt64, 0) + request = make([]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt64 - if err := elem.Decode(d); err != nil { + var elem float32 + v, err := d.Float32() + elem = float32(v) + if err != nil { return err } request = append(request, elem) @@ -6996,14 +7129,36 @@ func (s *Server) decodeTestRequestNumberInt64NullableArrayRequest(r *http.Reques }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestNumberInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilInt64, +func (s *Server) decodeTestRequestNumberFloatArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]float32, close func() error, rerr error, ) { @@ -7036,7 +7191,7 @@ func (s *Server) decodeTestRequestNumberInt64NullableArrayArrayRequest(r *http.R return req, close, nil } - var request [][]NilInt64 + var request [][]float32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -7048,13 +7203,15 @@ func (s *Server) decodeTestRequestNumberInt64NullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilInt64, 0) + request = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt64 - elem = make([]NilInt64, 0) + var elem []float32 + elem = make([]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt64 - if err := elemElem.Decode(d); err != nil { + var elemElem float32 + v, err := d.Float32() + elemElem = float32(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -7078,6 +7235,23 @@ func (s *Server) decodeTestRequestNumberInt64NullableArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -7099,8 +7273,8 @@ func (s *Server) decodeTestRequestNumberInt64NullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestNumberNullableRequest(r *http.Request, span trace.Span) ( - req OptNilFloat64, +func (s *Server) decodeTestRequestNumberFloatNullableRequest(r *http.Request, span trace.Span) ( + req OptNilFloat32, close func() error, rerr error, ) { @@ -7133,7 +7307,7 @@ func (s *Server) decodeTestRequestNumberNullableRequest(r *http.Request, span tr return req, close, nil } - var request OptNilFloat64 + var request OptNilFloat32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -7174,8 +7348,8 @@ func (s *Server) decodeTestRequestNumberNullableRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestNumberNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilFloat64, +func (s *Server) decodeTestRequestNumberFloatNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilFloat32, close func() error, rerr error, ) { @@ -7208,7 +7382,7 @@ func (s *Server) decodeTestRequestNumberNullableArrayRequest(r *http.Request, sp return req, close, nil } - var request []NilFloat64 + var request []NilFloat32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -7220,9 +7394,9 @@ func (s *Server) decodeTestRequestNumberNullableArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilFloat64, 0) + request = make([]NilFloat32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilFloat64 + var elem NilFloat32 if err := elem.Decode(d); err != nil { return err } @@ -7263,8 +7437,8 @@ func (s *Server) decodeTestRequestNumberNullableArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestNumberNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilFloat64, +func (s *Server) decodeTestRequestNumberFloatNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilFloat32, close func() error, rerr error, ) { @@ -7297,7 +7471,7 @@ func (s *Server) decodeTestRequestNumberNullableArrayArrayRequest(r *http.Reques return req, close, nil } - var request [][]NilFloat64 + var request [][]NilFloat32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -7309,12 +7483,12 @@ func (s *Server) decodeTestRequestNumberNullableArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilFloat64, 0) + request = make([][]NilFloat32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilFloat64 - elem = make([]NilFloat64, 0) + var elem []NilFloat32 + elem = make([]NilFloat32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilFloat64 + var elemElem NilFloat32 if err := elemElem.Decode(d); err != nil { return err } @@ -7377,8 +7551,8 @@ func (s *Server) decodeTestRequestNumberNullableArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredAnyRequest(r *http.Request, span trace.Span) ( - req jx.Raw, +func (s *Server) decodeTestRequestNumberInt32Request(r *http.Request, span trace.Span) ( + req OptInt32, close func() error, rerr error, ) { @@ -7397,6 +7571,9 @@ func (s *Server) decodeTestRequestRequiredAnyRequest(r *http.Request, span trace rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7405,24 +7582,23 @@ func (s *Server) decodeTestRequestRequiredAnyRequest(r *http.Request, span trace switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request jx.Raw + var request OptInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.RawAppend(nil) - request = jx.Raw(v) - if err != nil { + request.Reset() + if err := request.Decode(d); err != nil { return err } return nil @@ -7435,8 +7611,8 @@ func (s *Server) decodeTestRequestRequiredAnyRequest(r *http.Request, span trace } } -func (s *Server) decodeTestRequestRequiredBooleanRequest(r *http.Request, span trace.Span) ( - req bool, +func (s *Server) decodeTestRequestNumberInt32ArrayRequest(r *http.Request, span trace.Span) ( + req []int32, close func() error, rerr error, ) { @@ -7455,6 +7631,9 @@ func (s *Server) decodeTestRequestRequiredBooleanRequest(r *http.Request, span t rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7463,24 +7642,32 @@ func (s *Server) decodeTestRequestRequiredBooleanRequest(r *http.Request, span t switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request bool + var request []int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Bool() - request = bool(v) - if err != nil { + request = make([]int32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int32 + v, err := d.Int32() + elem = int32(v) + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { return err } return nil @@ -7493,8 +7680,8 @@ func (s *Server) decodeTestRequestRequiredBooleanRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestRequiredBooleanArrayRequest(r *http.Request, span trace.Span) ( - req []bool, +func (s *Server) decodeTestRequestNumberInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int32, close func() error, rerr error, ) { @@ -7513,6 +7700,9 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayRequest(r *http.Request, s rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7521,27 +7711,35 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayRequest(r *http.Request, s switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request []bool + var request [][]int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - request = make([]bool, 0) + request = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem bool - v, err := d.Bool() - elem = bool(v) - if err != nil { + var elem []int32 + elem = make([]int32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem int32 + v, err := d.Int32() + elemElem = int32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { return err } request = append(request, elem) @@ -7554,8 +7752,22 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayRequest(r *http.Request, s return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { - if request == nil { - return errors.New("nil is invalid value") + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} } return nil }(); err != nil { @@ -7567,8 +7779,8 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestRequiredBooleanArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]bool, +func (s *Server) decodeTestRequestNumberInt32NullableRequest(r *http.Request, span trace.Span) ( + req OptNilInt32, close func() error, rerr error, ) { @@ -7587,6 +7799,9 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayArrayRequest(r *http.Reque rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7595,30 +7810,155 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayArrayRequest(r *http.Reque switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request [][]bool + var request OptNilInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]bool, 0) + request.Reset() + if err := request.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestNumberInt32NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilInt32, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []NilInt32 + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []bool - elem = make([]bool, 0) + var elem NilInt32 + if err := elem.Decode(d); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestNumberInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilInt32, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]NilInt32 + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilInt32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilInt32 + elem = make([]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem bool - v, err := d.Bool() - elemElem = bool(v) - if err != nil { + var elemElem NilInt32 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -7636,9 +7976,6 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayArrayRequest(r *http.Reque return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -7666,8 +8003,8 @@ func (s *Server) decodeTestRequestRequiredBooleanArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredBooleanNullableRequest(r *http.Request, span trace.Span) ( - req NilBool, +func (s *Server) decodeTestRequestNumberInt64Request(r *http.Request, span trace.Span) ( + req OptInt64, close func() error, rerr error, ) { @@ -7686,6 +8023,9 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableRequest(r *http.Request rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7694,21 +8034,22 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableRequest(r *http.Request switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request NilBool + var request OptInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { + request.Reset() if err := request.Decode(d); err != nil { return err } @@ -7722,8 +8063,8 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredBooleanNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilBool, +func (s *Server) decodeTestRequestNumberInt64ArrayRequest(r *http.Request, span trace.Span) ( + req []int64, close func() error, rerr error, ) { @@ -7742,6 +8083,9 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableArrayRequest(r *http.Re rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7750,25 +8094,27 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableArrayRequest(r *http.Re switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request []NilBool + var request []int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilBool, 0) + request = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilBool - if err := elem.Decode(d); err != nil { + var elem int64 + v, err := d.Int64() + elem = int64(v) + if err != nil { return err } request = append(request, elem) @@ -7780,22 +8126,14 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableArrayRequest(r *http.Re }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilBool, +func (s *Server) decodeTestRequestNumberInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int64, close func() error, rerr error, ) { @@ -7814,6 +8152,9 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r *ht rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7822,28 +8163,30 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r *ht switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request [][]NilBool + var request [][]int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilBool, 0) + request = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilBool - elem = make([]NilBool, 0) + var elem []int64 + elem = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilBool - if err := elemElem.Decode(d); err != nil { + var elemElem int64 + v, err := d.Int64() + elemElem = int64(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -7861,9 +8204,6 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r *ht return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -7891,8 +8231,8 @@ func (s *Server) decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredEmptyStructRequest(r *http.Request, span trace.Span) ( - req TestRequestRequiredEmptyStructReq, +func (s *Server) decodeTestRequestNumberInt64NullableRequest(r *http.Request, span trace.Span) ( + req OptNilInt64, close func() error, rerr error, ) { @@ -7911,6 +8251,9 @@ func (s *Server) decodeTestRequestRequiredEmptyStructRequest(r *http.Request, sp rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7919,21 +8262,22 @@ func (s *Server) decodeTestRequestRequiredEmptyStructRequest(r *http.Request, sp switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request TestRequestRequiredEmptyStructReq + var request OptNilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { + request.Reset() if err := request.Decode(d); err != nil { return err } @@ -7947,8 +8291,8 @@ func (s *Server) decodeTestRequestRequiredEmptyStructRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestRequiredFormatTestRequest(r *http.Request, span trace.Span) ( - req TestRequestRequiredFormatTestReq, +func (s *Server) decodeTestRequestNumberInt64NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilInt64, close func() error, rerr error, ) { @@ -7967,6 +8311,9 @@ func (s *Server) decodeTestRequestRequiredFormatTestRequest(r *http.Request, spa rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -7975,33 +8322,130 @@ func (s *Server) decodeTestRequestRequiredFormatTestRequest(r *http.Request, spa switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request TestRequestRequiredFormatTestReq + var request []NilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + request = make([]NilInt64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilInt64 + if err := elem.Decode(d); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestNumberInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilInt64, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]NilInt64 + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Validate(); err != nil { + request = make([][]NilInt64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilInt64 + elem = make([]NilInt64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilInt64 + if err := elemElem.Decode(d); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { return err } return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") } @@ -8011,8 +8455,8 @@ func (s *Server) decodeTestRequestRequiredFormatTestRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestRequiredIntegerRequest(r *http.Request, span trace.Span) ( - req int, +func (s *Server) decodeTestRequestNumberNullableRequest(r *http.Request, span trace.Span) ( + req OptNilFloat64, close func() error, rerr error, ) { @@ -8031,6 +8475,9 @@ func (s *Server) decodeTestRequestRequiredIntegerRequest(r *http.Request, span t rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -8039,38 +8486,52 @@ func (s *Server) decodeTestRequestRequiredIntegerRequest(r *http.Request, span t switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request int + var request OptNilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Int() - request = int(v) - if err != nil { + request.Reset() + if err := request.Decode(d); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredIntegerArrayRequest(r *http.Request, span trace.Span) ( - req []int, +func (s *Server) decodeTestRequestNumberNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilFloat64, close func() error, rerr error, ) { @@ -8089,6 +8550,9 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayRequest(r *http.Request, s rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -8097,27 +8561,25 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayRequest(r *http.Request, s switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request []int + var request []NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int, 0) + request = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int - v, err := d.Int() - elem = int(v) - if err != nil { + var elem NilFloat64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -8130,8 +8592,22 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayRequest(r *http.Request, s return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { - if request == nil { - return errors.New("nil is invalid value") + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} } return nil }(); err != nil { @@ -8143,8 +8619,8 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestRequiredIntegerArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int, +func (s *Server) decodeTestRequestNumberNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilFloat64, close func() error, rerr error, ) { @@ -8163,6 +8639,9 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayArrayRequest(r *http.Reque rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -8171,30 +8650,28 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayArrayRequest(r *http.Reque switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request [][]int + var request [][]NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int, 0) + request = make([][]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int - elem = make([]int, 0) + var elem []NilFloat64 + elem = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int - v, err := d.Int() - elemElem = int(v) - if err != nil { + var elemElem NilFloat64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -8212,15 +8689,29 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayArrayRequest(r *http.Reque return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { - if request == nil { - return errors.New("nil is invalid value") - } var failures []validate.FieldError for i, elem := range request { if err := func() error { if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -8242,8 +8733,8 @@ func (s *Server) decodeTestRequestRequiredIntegerArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredIntegerInt32Request(r *http.Request, span trace.Span) ( - req int32, +func (s *Server) decodeTestRequestRequiredAnyRequest(r *http.Request, span trace.Span) ( + req jx.Raw, close func() error, rerr error, ) { @@ -8273,7 +8764,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32Request(r *http.Request, s return req, close, validate.ErrBodyRequired } - var request int32 + var request jx.Raw buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8285,8 +8776,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32Request(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Int32() - request = int32(v) + v, err := d.RawAppend(nil) + request = jx.Raw(v) if err != nil { return err } @@ -8300,8 +8791,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32Request(r *http.Request, s } } -func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayRequest(r *http.Request, span trace.Span) ( - req []int32, +func (s *Server) decodeTestRequestRequiredBooleanRequest(r *http.Request, span trace.Span) ( + req bool, close func() error, rerr error, ) { @@ -8331,7 +8822,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayRequest(r *http.Reque return req, close, validate.ErrBodyRequired } - var request []int32 + var request bool buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8343,11 +8834,69 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int32, 0) + v, err := d.Bool() + request = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredBooleanArrayRequest(r *http.Request, span trace.Span) ( + req []bool, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request []bool + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int32 - v, err := d.Int32() - elem = int32(v) + var elem bool + v, err := d.Bool() + elem = bool(v) if err != nil { return err } @@ -8374,8 +8923,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int32, +func (s *Server) decodeTestRequestRequiredBooleanArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]bool, close func() error, rerr error, ) { @@ -8405,7 +8954,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayArrayRequest(r *http. return req, close, validate.ErrBodyRequired } - var request [][]int32 + var request [][]bool buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8417,14 +8966,14 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int32, 0) + request = make([][]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int32 - elem = make([]int32, 0) + var elem []bool + elem = make([]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int32 - v, err := d.Int32() - elemElem = int32(v) + var elemElem bool + v, err := d.Bool() + elemElem = bool(v) if err != nil { return err } @@ -8473,8 +9022,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredIntegerInt32NullableRequest(r *http.Request, span trace.Span) ( - req NilInt32, +func (s *Server) decodeTestRequestRequiredBooleanNullableRequest(r *http.Request, span trace.Span) ( + req NilBool, close func() error, rerr error, ) { @@ -8504,7 +9053,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request NilInt32 + var request NilBool buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8529,8 +9078,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilInt32, +func (s *Server) decodeTestRequestRequiredBooleanNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilBool, close func() error, rerr error, ) { @@ -8560,7 +9109,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request []NilInt32 + var request []NilBool buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8572,9 +9121,9 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilInt32, 0) + request = make([]NilBool, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt32 + var elem NilBool if err := elem.Decode(d); err != nil { return err } @@ -8601,8 +9150,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilInt32, +func (s *Server) decodeTestRequestRequiredBooleanNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilBool, close func() error, rerr error, ) { @@ -8632,7 +9181,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest( return req, close, validate.ErrBodyRequired } - var request [][]NilInt32 + var request [][]NilBool buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8644,12 +9193,12 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest( d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilInt32, 0) + request = make([][]NilBool, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt32 - elem = make([]NilInt32, 0) + var elem []NilBool + elem = make([]NilBool, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt32 + var elemElem NilBool if err := elemElem.Decode(d); err != nil { return err } @@ -8698,8 +9247,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest( } } -func (s *Server) decodeTestRequestRequiredIntegerInt64Request(r *http.Request, span trace.Span) ( - req int64, +func (s *Server) decodeTestRequestRequiredEmptyStructRequest(r *http.Request, span trace.Span) ( + req TestRequestRequiredEmptyStructReq, close func() error, rerr error, ) { @@ -8729,7 +9278,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64Request(r *http.Request, s return req, close, validate.ErrBodyRequired } - var request int64 + var request TestRequestRequiredEmptyStructReq buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8741,8 +9290,128 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64Request(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Int64() - request = int64(v) + if err := request.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredFormatTestRequest(r *http.Request, span trace.Span) ( + req TestRequestRequiredFormatTestReq, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request TestRequestRequiredFormatTestReq + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + if err := request.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + if err := request.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredIntegerRequest(r *http.Request, span trace.Span) ( + req int, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request int + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Int() + request = int(v) if err != nil { return err } @@ -8756,8 +9425,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64Request(r *http.Request, s } } -func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayRequest(r *http.Request, span trace.Span) ( - req []int64, +func (s *Server) decodeTestRequestRequiredIntegerArrayRequest(r *http.Request, span trace.Span) ( + req []int, close func() error, rerr error, ) { @@ -8787,7 +9456,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayRequest(r *http.Reque return req, close, validate.ErrBodyRequired } - var request []int64 + var request []int buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8799,11 +9468,11 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int64, 0) + request = make([]int, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int64 - v, err := d.Int64() - elem = int64(v) + var elem int + v, err := d.Int() + elem = int(v) if err != nil { return err } @@ -8830,8 +9499,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int64, +func (s *Server) decodeTestRequestRequiredIntegerArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int, close func() error, rerr error, ) { @@ -8861,7 +9530,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayArrayRequest(r *http. return req, close, validate.ErrBodyRequired } - var request [][]int64 + var request [][]int buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8873,14 +9542,14 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int64, 0) + request = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int64 - elem = make([]int64, 0) + var elem []int + elem = make([]int, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int64 - v, err := d.Int64() - elemElem = int64(v) + var elemElem int + v, err := d.Int() + elemElem = int(v) if err != nil { return err } @@ -8929,8 +9598,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredIntegerInt64NullableRequest(r *http.Request, span trace.Span) ( - req NilInt64, +func (s *Server) decodeTestRequestRequiredIntegerInt32Request(r *http.Request, span trace.Span) ( + req int32, close func() error, rerr error, ) { @@ -8960,7 +9629,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request NilInt64 + var request int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -8972,7 +9641,9 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := d.Int32() + request = int32(v) + if err != nil { return err } return nil @@ -8985,8 +9656,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilInt64, +func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayRequest(r *http.Request, span trace.Span) ( + req []int32, close func() error, rerr error, ) { @@ -9016,7 +9687,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request []NilInt64 + var request []int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9028,10 +9699,12 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilInt64, 0) + request = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt64 - if err := elem.Decode(d); err != nil { + var elem int32 + v, err := d.Int32() + elem = int32(v) + if err != nil { return err } request = append(request, elem) @@ -9057,8 +9730,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilInt64, +func (s *Server) decodeTestRequestRequiredIntegerInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int32, close func() error, rerr error, ) { @@ -9088,7 +9761,7 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest( return req, close, validate.ErrBodyRequired } - var request [][]NilInt64 + var request [][]int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9100,13 +9773,15 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest( d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilInt64, 0) + request = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt64 - elem = make([]NilInt64, 0) + var elem []int32 + elem = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt64 - if err := elemElem.Decode(d); err != nil { + var elemElem int32 + v, err := d.Int32() + elemElem = int32(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -9154,8 +9829,8 @@ func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest( } } -func (s *Server) decodeTestRequestRequiredIntegerNullableRequest(r *http.Request, span trace.Span) ( - req NilInt, +func (s *Server) decodeTestRequestRequiredIntegerInt32NullableRequest(r *http.Request, span trace.Span) ( + req NilInt32, close func() error, rerr error, ) { @@ -9185,7 +9860,7 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request NilInt + var request NilInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9210,8 +9885,8 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredIntegerNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilInt, +func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilInt32, close func() error, rerr error, ) { @@ -9241,7 +9916,7 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request []NilInt + var request []NilInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9253,9 +9928,9 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilInt, 0) + request = make([]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt + var elem NilInt32 if err := elem.Decode(d); err != nil { return err } @@ -9282,8 +9957,8 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredIntegerNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilInt, +func (s *Server) decodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilInt32, close func() error, rerr error, ) { @@ -9313,7 +9988,7 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableArrayArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request [][]NilInt + var request [][]NilInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9325,12 +10000,12 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilInt, 0) + request = make([][]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt - elem = make([]NilInt, 0) + var elem []NilInt32 + elem = make([]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt + var elemElem NilInt32 if err := elemElem.Decode(d); err != nil { return err } @@ -9379,8 +10054,8 @@ func (s *Server) decodeTestRequestRequiredIntegerNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredIntegerUnixRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredIntegerInt64Request(r *http.Request, span trace.Span) ( + req int64, close func() error, rerr error, ) { @@ -9410,7 +10085,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixRequest(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request time.Time + var request int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9422,8 +10097,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeUnixSeconds(d) - request = v + v, err := d.Int64() + request = int64(v) if err != nil { return err } @@ -9437,8 +10112,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestRequiredIntegerUnixArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayRequest(r *http.Request, span trace.Span) ( + req []int64, close func() error, rerr error, ) { @@ -9468,7 +10143,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9480,11 +10155,11 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixSeconds(d) - elem = v + var elem int64 + v, err := d.Int64() + elem = int64(v) if err != nil { return err } @@ -9511,8 +10186,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredIntegerUnixArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredIntegerInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int64, close func() error, rerr error, ) { @@ -9542,7 +10217,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixArrayArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9554,14 +10229,14 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []int64 + elem = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixSeconds(d) - elemElem = v + var elemElem int64 + v, err := d.Int64() + elemElem = int64(v) if err != nil { return err } @@ -9610,8 +10285,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMicroRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredIntegerInt64NullableRequest(r *http.Request, span trace.Span) ( + req NilInt64, close func() error, rerr error, ) { @@ -9641,7 +10316,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request time.Time + var request NilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9653,9 +10328,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeUnixMicro(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -9668,8 +10341,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilInt64, close func() error, rerr error, ) { @@ -9699,7 +10372,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []NilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9711,12 +10384,10 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixMicro(d) - elem = v - if err != nil { + var elem NilInt64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -9742,8 +10413,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilInt64, close func() error, rerr error, ) { @@ -9773,7 +10444,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(r *h return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]NilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9785,15 +10456,13 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(r *h d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilInt64 + elem = make([]NilInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixMicro(d) - elemElem = v - if err != nil { + var elemElem NilInt64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -9841,8 +10510,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(r *h } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableRequest(r *http.Request, span trace.Span) ( - req NilUnixMicro, +func (s *Server) decodeTestRequestRequiredIntegerNullableRequest(r *http.Request, span trace.Span) ( + req NilInt, close func() error, rerr error, ) { @@ -9872,7 +10541,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableRequest(r *htt return req, close, validate.ErrBodyRequired } - var request NilUnixMicro + var request NilInt buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9884,7 +10553,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeUnixMicro); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -9897,8 +10566,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixMicro, +func (s *Server) decodeTestRequestRequiredIntegerNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilInt, close func() error, rerr error, ) { @@ -9928,7 +10597,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(r return req, close, validate.ErrBodyRequired } - var request []NilUnixMicro + var request []NilInt buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -9940,10 +10609,10 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixMicro, 0) + request = make([]NilInt, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixMicro - if err := elem.Decode(d, json.DecodeUnixMicro); err != nil { + var elem NilInt + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -9969,8 +10638,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixMicro, +func (s *Server) decodeTestRequestRequiredIntegerNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilInt, close func() error, rerr error, ) { @@ -10000,7 +10669,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequ return req, close, validate.ErrBodyRequired } - var request [][]NilUnixMicro + var request [][]NilInt buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10012,13 +10681,13 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequ d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixMicro, 0) + request = make([][]NilInt, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixMicro - elem = make([]NilUnixMicro, 0) + var elem []NilInt + elem = make([]NilInt, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixMicro - if err := elemElem.Decode(d, json.DecodeUnixMicro); err != nil { + var elemElem NilInt + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -10066,8 +10735,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequ } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMilliRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredIntegerUintRequest(r *http.Request, span trace.Span) ( + req uint, close func() error, rerr error, ) { @@ -10097,7 +10766,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request time.Time + var request uint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10109,8 +10778,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeUnixMilli(d) - request = v + v, err := d.UInt() + request = uint(v) if err != nil { return err } @@ -10124,8 +10793,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredIntegerUint32Request(r *http.Request, span trace.Span) ( + req uint32, close func() error, rerr error, ) { @@ -10155,7 +10824,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request []time.Time + var request uint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10167,11 +10836,69 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + v, err := d.UInt32() + request = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredIntegerUint32ArrayRequest(r *http.Request, span trace.Span) ( + req []uint32, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request []uint32 + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixMilli(d) - elem = v + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) if err != nil { return err } @@ -10198,8 +10925,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredIntegerUint32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uint32, close func() error, rerr error, ) { @@ -10229,7 +10956,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(r *h return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]uint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10241,14 +10968,14 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(r *h d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []uint32 + elem = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixMilli(d) - elemElem = v + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) if err != nil { return err } @@ -10297,8 +11024,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(r *h } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableRequest(r *http.Request, span trace.Span) ( - req NilUnixMilli, +func (s *Server) decodeTestRequestRequiredIntegerUint32NullableRequest(r *http.Request, span trace.Span) ( + req NilUint32, close func() error, rerr error, ) { @@ -10328,7 +11055,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableRequest(r *htt return req, close, validate.ErrBodyRequired } - var request NilUnixMilli + var request NilUint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10340,7 +11067,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeUnixMilli); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -10353,8 +11080,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixMilli, +func (s *Server) decodeTestRequestRequiredIntegerUint32NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUint32, close func() error, rerr error, ) { @@ -10384,7 +11111,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(r return req, close, validate.ErrBodyRequired } - var request []NilUnixMilli + var request []NilUint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10396,10 +11123,10 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixMilli, 0) + request = make([]NilUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixMilli - if err := elem.Decode(d, json.DecodeUnixMilli); err != nil { + var elem NilUint32 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -10425,8 +11152,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixMilli, +func (s *Server) decodeTestRequestRequiredIntegerUint32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUint32, close func() error, rerr error, ) { @@ -10456,7 +11183,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequ return req, close, validate.ErrBodyRequired } - var request [][]NilUnixMilli + var request [][]NilUint32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10468,13 +11195,13 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequ d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixMilli, 0) + request = make([][]NilUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixMilli - elem = make([]NilUnixMilli, 0) + var elem []NilUint32 + elem = make([]NilUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixMilli - if err := elemElem.Decode(d, json.DecodeUnixMilli); err != nil { + var elemElem NilUint32 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -10522,8 +11249,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequ } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNanoRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredIntegerUint64Request(r *http.Request, span trace.Span) ( + req uint64, close func() error, rerr error, ) { @@ -10553,7 +11280,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request time.Time + var request uint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10565,8 +11292,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeUnixNano(d) - request = v + v, err := d.UInt64() + request = uint64(v) if err != nil { return err } @@ -10580,8 +11307,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredIntegerUint64ArrayRequest(r *http.Request, span trace.Span) ( + req []uint64, close func() error, rerr error, ) { @@ -10611,7 +11338,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []uint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10623,11 +11350,11 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeUnixNano(d) - elem = v + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) if err != nil { return err } @@ -10654,8 +11381,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredIntegerUint64ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uint64, close func() error, rerr error, ) { @@ -10685,7 +11412,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]uint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10697,14 +11424,14 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []uint64 + elem = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeUnixNano(d) - elemElem = v + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) if err != nil { return err } @@ -10753,8 +11480,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableRequest(r *http.Request, span trace.Span) ( - req NilUnixNano, +func (s *Server) decodeTestRequestRequiredIntegerUint64NullableRequest(r *http.Request, span trace.Span) ( + req NilUint64, close func() error, rerr error, ) { @@ -10784,7 +11511,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableRequest(r *http return req, close, validate.ErrBodyRequired } - var request NilUnixNano + var request NilUint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10796,7 +11523,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeUnixNano); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -10809,8 +11536,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableRequest(r *http } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixNano, +func (s *Server) decodeTestRequestRequiredIntegerUint64NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUint64, close func() error, rerr error, ) { @@ -10840,7 +11567,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(r return req, close, validate.ErrBodyRequired } - var request []NilUnixNano + var request []NilUint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10852,10 +11579,10 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixNano, 0) + request = make([]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixNano - if err := elem.Decode(d, json.DecodeUnixNano); err != nil { + var elem NilUint64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -10881,8 +11608,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixNano, +func (s *Server) decodeTestRequestRequiredIntegerUint64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUint64, close func() error, rerr error, ) { @@ -10912,7 +11639,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayReque return req, close, validate.ErrBodyRequired } - var request [][]NilUnixNano + var request [][]NilUint64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -10924,13 +11651,13 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayReque d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixNano, 0) + request = make([][]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixNano - elem = make([]NilUnixNano, 0) + var elem []NilUint64 + elem = make([]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixNano - if err := elemElem.Decode(d, json.DecodeUnixNano); err != nil { + var elemElem NilUint64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -10978,8 +11705,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayReque } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNullableRequest(r *http.Request, span trace.Span) ( - req NilUnixSeconds, +func (s *Server) decodeTestRequestRequiredIntegerUintArrayRequest(r *http.Request, span trace.Span) ( + req []uint, close func() error, rerr error, ) { @@ -11009,7 +11736,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request NilUnixSeconds + var request []uint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11021,21 +11748,39 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { + request = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixSeconds, +func (s *Server) decodeTestRequestRequiredIntegerUintArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uint, close func() error, rerr error, ) { @@ -11065,7 +11810,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request []NilUnixSeconds + var request [][]uint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11077,10 +11822,20 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixSeconds, 0) + request = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixSeconds - if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { return err } request = append(request, elem) @@ -11096,6 +11851,23 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r *htt if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -11106,8 +11878,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixSeconds, +func (s *Server) decodeTestRequestRequiredIntegerUintNullableRequest(r *http.Request, span trace.Span) ( + req NilUint, close func() error, rerr error, ) { @@ -11137,7 +11909,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilUnixSeconds + var request NilUint buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11149,13 +11921,141 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixSeconds, 0) + if err := request.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredIntegerUintNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUint, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request []NilUint + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixSeconds - elem = make([]NilUnixSeconds, 0) + var elem NilUint + if err := elem.Decode(d); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredIntegerUintNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUint, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request [][]NilUint + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilUint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilUint + elem = make([]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixSeconds - if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elemElem NilUint + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -11203,7 +12103,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredIntegerUnixRequest(r *http.Request, span trace.Span) ( req time.Time, close func() error, rerr error, @@ -11261,7 +12161,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredIntegerUnixArrayRequest(r *http.Request, span trace.Span) ( req []time.Time, close func() error, rerr error, @@ -11335,7 +12235,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredIntegerUnixArrayArrayRequest(r *http.Request, span trace.Span) ( req [][]time.Time, close func() error, rerr error, @@ -11434,8 +12334,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( - req NilUnixSeconds, +func (s *Server) decodeTestRequestRequiredIntegerUnixMicroRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -11465,7 +12365,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableRequest(r *h return req, close, validate.ErrBodyRequired } - var request NilUnixSeconds + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11477,7 +12377,9 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableRequest(r *h d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { + v, err := json.DecodeUnixMicro(d) + request = v + if err != nil { return err } return nil @@ -11490,8 +12392,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableRequest(r *h } } -func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUnixSeconds, +func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -11521,7 +12423,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest return req, close, validate.ErrBodyRequired } - var request []NilUnixSeconds + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11533,10 +12435,12 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUnixSeconds, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUnixSeconds - if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elem time.Time + v, err := json.DecodeUnixMicro(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -11562,8 +12466,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest } } -func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUnixSeconds, +func (s *Server) decodeTestRequestRequiredIntegerUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -11593,7 +12497,7 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRe return req, close, validate.ErrBodyRequired } - var request [][]NilUnixSeconds + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11605,13 +12509,15 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRe d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUnixSeconds, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUnixSeconds - elem = make([]NilUnixSeconds, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUnixSeconds - if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { + var elemElem time.Time + v, err := json.DecodeUnixMicro(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -11659,8 +12565,8 @@ func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRe } } -func (s *Server) decodeTestRequestRequiredNullRequest(r *http.Request, span trace.Span) ( - req struct{}, +func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableRequest(r *http.Request, span trace.Span) ( + req NilUnixMicro, close func() error, rerr error, ) { @@ -11690,7 +12596,7 @@ func (s *Server) decodeTestRequestRequiredNullRequest(r *http.Request, span trac return req, close, validate.ErrBodyRequired } - var request struct{} + var request NilUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11702,7 +12608,7 @@ func (s *Server) decodeTestRequestRequiredNullRequest(r *http.Request, span trac d := jx.DecodeBytes(buf) if err := func() error { - if err := d.Null(); err != nil { + if err := request.Decode(d, json.DecodeUnixMicro); err != nil { return err } return nil @@ -11715,8 +12621,8 @@ func (s *Server) decodeTestRequestRequiredNullRequest(r *http.Request, span trac } } -func (s *Server) decodeTestRequestRequiredNullArrayRequest(r *http.Request, span trace.Span) ( - req []struct{}, +func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixMicro, close func() error, rerr error, ) { @@ -11746,7 +12652,7 @@ func (s *Server) decodeTestRequestRequiredNullArrayRequest(r *http.Request, span return req, close, validate.ErrBodyRequired } - var request []struct{} + var request []NilUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11758,10 +12664,10 @@ func (s *Server) decodeTestRequestRequiredNullArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]struct{}, 0) + request = make([]NilUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem struct{} - if err := d.Null(); err != nil { + var elem NilUnixMicro + if err := elem.Decode(d, json.DecodeUnixMicro); err != nil { return err } request = append(request, elem) @@ -11787,8 +12693,8 @@ func (s *Server) decodeTestRequestRequiredNullArrayRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestRequiredNullArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]struct{}, +func (s *Server) decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixMicro, close func() error, rerr error, ) { @@ -11818,7 +12724,7 @@ func (s *Server) decodeTestRequestRequiredNullArrayArrayRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request [][]struct{} + var request [][]NilUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11830,13 +12736,13 @@ func (s *Server) decodeTestRequestRequiredNullArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]struct{}, 0) + request = make([][]NilUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []struct{} - elem = make([]struct{}, 0) + var elem []NilUnixMicro + elem = make([]NilUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem struct{} - if err := d.Null(); err != nil { + var elemElem NilUnixMicro + if err := elemElem.Decode(d, json.DecodeUnixMicro); err != nil { return err } elem = append(elem, elemElem) @@ -11884,8 +12790,8 @@ func (s *Server) decodeTestRequestRequiredNullArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredNullNullableRequest(r *http.Request, span trace.Span) ( - req struct{}, +func (s *Server) decodeTestRequestRequiredIntegerUnixMilliRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -11915,7 +12821,7 @@ func (s *Server) decodeTestRequestRequiredNullNullableRequest(r *http.Request, s return req, close, validate.ErrBodyRequired } - var request struct{} + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11927,7 +12833,9 @@ func (s *Server) decodeTestRequestRequiredNullNullableRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - if err := d.Null(); err != nil { + v, err := json.DecodeUnixMilli(d) + request = v + if err != nil { return err } return nil @@ -11940,8 +12848,8 @@ func (s *Server) decodeTestRequestRequiredNullNullableRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestRequiredNullNullableArrayRequest(r *http.Request, span trace.Span) ( - req []struct{}, +func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -11971,7 +12879,7 @@ func (s *Server) decodeTestRequestRequiredNullNullableArrayRequest(r *http.Reque return req, close, validate.ErrBodyRequired } - var request []struct{} + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -11983,10 +12891,12 @@ func (s *Server) decodeTestRequestRequiredNullNullableArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([]struct{}, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem struct{} - if err := d.Null(); err != nil { + var elem time.Time + v, err := json.DecodeUnixMilli(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -12012,8 +12922,8 @@ func (s *Server) decodeTestRequestRequiredNullNullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredNullNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]struct{}, +func (s *Server) decodeTestRequestRequiredIntegerUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -12043,7 +12953,7 @@ func (s *Server) decodeTestRequestRequiredNullNullableArrayArrayRequest(r *http. return req, close, validate.ErrBodyRequired } - var request [][]struct{} + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12055,13 +12965,15 @@ func (s *Server) decodeTestRequestRequiredNullNullableArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]struct{}, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []struct{} - elem = make([]struct{}, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem struct{} - if err := d.Null(); err != nil { + var elemElem time.Time + v, err := json.DecodeUnixMilli(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -12109,8 +13021,8 @@ func (s *Server) decodeTestRequestRequiredNullNullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredNumberRequest(r *http.Request, span trace.Span) ( - req float64, +func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableRequest(r *http.Request, span trace.Span) ( + req NilUnixMilli, close func() error, rerr error, ) { @@ -12140,7 +13052,7 @@ func (s *Server) decodeTestRequestRequiredNumberRequest(r *http.Request, span tr return req, close, validate.ErrBodyRequired } - var request float64 + var request NilUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12152,31 +13064,21 @@ func (s *Server) decodeTestRequestRequiredNumberRequest(r *http.Request, span tr d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Float64() - request = float64(v) - if err != nil { + if err := request.Decode(d, json.DecodeUnixMilli); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.Float{}).Validate(float64(request)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredNumberArrayRequest(r *http.Request, span trace.Span) ( - req []float64, +func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixMilli, close func() error, rerr error, ) { @@ -12206,7 +13108,7 @@ func (s *Server) decodeTestRequestRequiredNumberArrayRequest(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request []float64 + var request []NilUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12218,12 +13120,10 @@ func (s *Server) decodeTestRequestRequiredNumberArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]float64, 0) + request = make([]NilUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem float64 - v, err := d.Float64() - elem = float64(v) - if err != nil { + var elem NilUnixMilli + if err := elem.Decode(d, json.DecodeUnixMilli); err != nil { return err } request = append(request, elem) @@ -12239,23 +13139,6 @@ func (s *Server) decodeTestRequestRequiredNumberArrayRequest(r *http.Request, sp if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -12266,8 +13149,8 @@ func (s *Server) decodeTestRequestRequiredNumberArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestRequiredNumberArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]float64, +func (s *Server) decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixMilli, close func() error, rerr error, ) { @@ -12297,7 +13180,7 @@ func (s *Server) decodeTestRequestRequiredNumberArrayArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request [][]float64 + var request [][]NilUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12309,15 +13192,13 @@ func (s *Server) decodeTestRequestRequiredNumberArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]float64, 0) + request = make([][]NilUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []float64 - elem = make([]float64, 0) + var elem []NilUnixMilli + elem = make([]NilUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem float64 - v, err := d.Float64() - elemElem = float64(v) - if err != nil { + var elemElem NilUnixMilli + if err := elemElem.Decode(d, json.DecodeUnixMilli); err != nil { return err } elem = append(elem, elemElem) @@ -12344,23 +13225,6 @@ func (s *Server) decodeTestRequestRequiredNumberArrayArrayRequest(r *http.Reques if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -12382,8 +13246,8 @@ func (s *Server) decodeTestRequestRequiredNumberArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredNumberDoubleRequest(r *http.Request, span trace.Span) ( - req float64, +func (s *Server) decodeTestRequestRequiredIntegerUnixNanoRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -12413,7 +13277,7 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleRequest(r *http.Request, s return req, close, validate.ErrBodyRequired } - var request float64 + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12425,8 +13289,8 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Float64() - request = float64(v) + v, err := json.DecodeUnixNano(d) + request = v if err != nil { return err } @@ -12434,22 +13298,14 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleRequest(r *http.Request, s }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.Float{}).Validate(float64(request)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredNumberDoubleArrayRequest(r *http.Request, span trace.Span) ( - req []float64, +func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -12479,7 +13335,7 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayRequest(r *http.Reque return req, close, validate.ErrBodyRequired } - var request []float64 + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12491,11 +13347,11 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([]float64, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem float64 - v, err := d.Float64() - elem = float64(v) + var elem time.Time + v, err := json.DecodeUnixNano(d) + elem = v if err != nil { return err } @@ -12512,23 +13368,6 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayRequest(r *http.Reque if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -12539,8 +13378,8 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]float64, +func (s *Server) decodeTestRequestRequiredIntegerUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -12570,7 +13409,7 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r *http. return req, close, validate.ErrBodyRequired } - var request [][]float64 + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12582,14 +13421,14 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]float64, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []float64 - elem = make([]float64, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem float64 - v, err := d.Float64() - elemElem = float64(v) + var elemElem time.Time + v, err := json.DecodeUnixNano(d) + elemElem = v if err != nil { return err } @@ -12617,23 +13456,6 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r *http. if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -12655,8 +13477,8 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredNumberDoubleNullableRequest(r *http.Request, span trace.Span) ( - req NilFloat64, +func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableRequest(r *http.Request, span trace.Span) ( + req NilUnixNano, close func() error, rerr error, ) { @@ -12686,7 +13508,7 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request NilFloat64 + var request NilUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12698,29 +13520,21 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeUnixNano); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilFloat64, +func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixNano, close func() error, rerr error, ) { @@ -12750,7 +13564,7 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request []NilFloat64 + var request []NilUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12762,10 +13576,10 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilFloat64, 0) + request = make([]NilUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilFloat64 - if err := elem.Decode(d); err != nil { + var elem NilUnixNano + if err := elem.Decode(d, json.DecodeUnixNano); err != nil { return err } request = append(request, elem) @@ -12781,23 +13595,6 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r *ht if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -12808,8 +13605,8 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilFloat64, +func (s *Server) decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixNano, close func() error, rerr error, ) { @@ -12839,7 +13636,7 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest( return req, close, validate.ErrBodyRequired } - var request [][]NilFloat64 + var request [][]NilUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12851,13 +13648,13 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest( d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilFloat64, 0) + request = make([][]NilUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilFloat64 - elem = make([]NilFloat64, 0) + var elem []NilUnixNano + elem = make([]NilUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilFloat64 - if err := elemElem.Decode(d); err != nil { + var elemElem NilUnixNano + if err := elemElem.Decode(d, json.DecodeUnixNano); err != nil { return err } elem = append(elem, elemElem) @@ -12884,23 +13681,6 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest( if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -12922,8 +13702,8 @@ func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest( } } -func (s *Server) decodeTestRequestRequiredNumberFloatRequest(r *http.Request, span trace.Span) ( - req float32, +func (s *Server) decodeTestRequestRequiredIntegerUnixNullableRequest(r *http.Request, span trace.Span) ( + req NilUnixSeconds, close func() error, rerr error, ) { @@ -12953,7 +13733,7 @@ func (s *Server) decodeTestRequestRequiredNumberFloatRequest(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request float32 + var request NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -12965,31 +13745,21 @@ func (s *Server) decodeTestRequestRequiredNumberFloatRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Float32() - request = float32(v) - if err != nil { + if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.Float{}).Validate(float64(request)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredNumberFloatArrayRequest(r *http.Request, span trace.Span) ( - req []float32, +func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixSeconds, close func() error, rerr error, ) { @@ -13019,7 +13789,7 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request []float32 + var request []NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13031,12 +13801,10 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]float32, 0) + request = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem float32 - v, err := d.Float32() - elem = float32(v) - if err != nil { + var elem NilUnixSeconds + if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { return err } request = append(request, elem) @@ -13052,23 +13820,6 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayRequest(r *http.Reques if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -13079,8 +13830,8 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredNumberFloatArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]float32, +func (s *Server) decodeTestRequestRequiredIntegerUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixSeconds, close func() error, rerr error, ) { @@ -13110,7 +13861,7 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request [][]float32 + var request [][]NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13122,15 +13873,13 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]float32, 0) + request = make([][]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []float32 - elem = make([]float32, 0) + var elem []NilUnixSeconds + elem = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem float32 - v, err := d.Float32() - elemElem = float32(v) - if err != nil { + var elemElem NilUnixSeconds + if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { return err } elem = append(elem, elemElem) @@ -13157,23 +13906,6 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -13195,8 +13927,8 @@ func (s *Server) decodeTestRequestRequiredNumberFloatArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredNumberFloatNullableRequest(r *http.Request, span trace.Span) ( - req NilFloat32, +func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -13226,7 +13958,7 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request NilFloat32 + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13238,29 +13970,23 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := json.DecodeUnixSeconds(d) + request = v + if err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilFloat32, +func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -13290,7 +14016,7 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request []NilFloat32 + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13302,10 +14028,12 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilFloat32, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilFloat32 - if err := elem.Decode(d); err != nil { + var elem time.Time + v, err := json.DecodeUnixSeconds(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -13321,23 +14049,6 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayRequest(r *htt if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -13348,8 +14059,8 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilFloat32, +func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -13379,7 +14090,7 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilFloat32 + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13391,13 +14102,15 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilFloat32, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilFloat32 - elem = make([]NilFloat32, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilFloat32 - if err := elemElem.Decode(d); err != nil { + var elemElem time.Time + v, err := json.DecodeUnixSeconds(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -13424,23 +14137,6 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -13462,8 +14158,8 @@ func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredNumberInt32Request(r *http.Request, span trace.Span) ( - req int32, +func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( + req NilUnixSeconds, close func() error, rerr error, ) { @@ -13493,7 +14189,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32Request(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request int32 + var request NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13505,9 +14201,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32Request(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Int32() - request = int32(v) - if err != nil { + if err := request.Decode(d, json.DecodeUnixSeconds); err != nil { return err } return nil @@ -13520,8 +14214,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt32Request(r *http.Request, sp } } -func (s *Server) decodeTestRequestRequiredNumberInt32ArrayRequest(r *http.Request, span trace.Span) ( - req []int32, +func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUnixSeconds, close func() error, rerr error, ) { @@ -13551,7 +14245,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32ArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request []int32 + var request []NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13563,12 +14257,10 @@ func (s *Server) decodeTestRequestRequiredNumberInt32ArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int32, 0) + request = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int32 - v, err := d.Int32() - elem = int32(v) - if err != nil { + var elem NilUnixSeconds + if err := elem.Decode(d, json.DecodeUnixSeconds); err != nil { return err } request = append(request, elem) @@ -13594,8 +14286,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt32ArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredNumberInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int32, +func (s *Server) decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUnixSeconds, close func() error, rerr error, ) { @@ -13625,7 +14317,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32ArrayArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request [][]int32 + var request [][]NilUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13637,15 +14329,13 @@ func (s *Server) decodeTestRequestRequiredNumberInt32ArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int32, 0) + request = make([][]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int32 - elem = make([]int32, 0) + var elem []NilUnixSeconds + elem = make([]NilUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int32 - v, err := d.Int32() - elemElem = int32(v) - if err != nil { + var elemElem NilUnixSeconds + if err := elemElem.Decode(d, json.DecodeUnixSeconds); err != nil { return err } elem = append(elem, elemElem) @@ -13693,8 +14383,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt32ArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredNumberInt32NullableRequest(r *http.Request, span trace.Span) ( - req NilInt32, +func (s *Server) decodeTestRequestRequiredNullRequest(r *http.Request, span trace.Span) ( + req struct{}, close func() error, rerr error, ) { @@ -13724,7 +14414,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request NilInt32 + var request struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13736,7 +14426,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + if err := d.Null(); err != nil { return err } return nil @@ -13749,8 +14439,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilInt32, +func (s *Server) decodeTestRequestRequiredNullArrayRequest(r *http.Request, span trace.Span) ( + req []struct{}, close func() error, rerr error, ) { @@ -13780,7 +14470,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request []NilInt32 + var request []struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13792,10 +14482,10 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilInt32, 0) + request = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt32 - if err := elem.Decode(d); err != nil { + var elem struct{} + if err := d.Null(); err != nil { return err } request = append(request, elem) @@ -13821,8 +14511,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilInt32, +func (s *Server) decodeTestRequestRequiredNullArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]struct{}, close func() error, rerr error, ) { @@ -13852,7 +14542,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilInt32 + var request [][]struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13864,13 +14554,13 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilInt32, 0) + request = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt32 - elem = make([]NilInt32, 0) + var elem []struct{} + elem = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt32 - if err := elemElem.Decode(d); err != nil { + var elemElem struct{} + if err := d.Null(); err != nil { return err } elem = append(elem, elemElem) @@ -13918,8 +14608,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredNumberInt64Request(r *http.Request, span trace.Span) ( - req int64, +func (s *Server) decodeTestRequestRequiredNullNullableRequest(r *http.Request, span trace.Span) ( + req struct{}, close func() error, rerr error, ) { @@ -13949,7 +14639,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt64Request(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request int64 + var request struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -13961,9 +14651,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt64Request(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Int64() - request = int64(v) - if err != nil { + if err := d.Null(); err != nil { return err } return nil @@ -13976,8 +14664,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt64Request(r *http.Request, sp } } -func (s *Server) decodeTestRequestRequiredNumberInt64ArrayRequest(r *http.Request, span trace.Span) ( - req []int64, +func (s *Server) decodeTestRequestRequiredNullNullableArrayRequest(r *http.Request, span trace.Span) ( + req []struct{}, close func() error, rerr error, ) { @@ -14007,7 +14695,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt64ArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request []int64 + var request []struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14019,12 +14707,10 @@ func (s *Server) decodeTestRequestRequiredNumberInt64ArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int64, 0) + request = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int64 - v, err := d.Int64() - elem = int64(v) - if err != nil { + var elem struct{} + if err := d.Null(); err != nil { return err } request = append(request, elem) @@ -14050,8 +14736,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt64ArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredNumberInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int64, +func (s *Server) decodeTestRequestRequiredNullNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]struct{}, close func() error, rerr error, ) { @@ -14081,7 +14767,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt64ArrayArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request [][]int64 + var request [][]struct{} buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14093,15 +14779,13 @@ func (s *Server) decodeTestRequestRequiredNumberInt64ArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int64, 0) + request = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int64 - elem = make([]int64, 0) + var elem []struct{} + elem = make([]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int64 - v, err := d.Int64() - elemElem = int64(v) - if err != nil { + var elemElem struct{} + if err := d.Null(); err != nil { return err } elem = append(elem, elemElem) @@ -14149,8 +14833,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt64ArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredNumberInt64NullableRequest(r *http.Request, span trace.Span) ( - req NilInt64, +func (s *Server) decodeTestRequestRequiredNumberRequest(r *http.Request, span trace.Span) ( + req float64, close func() error, rerr error, ) { @@ -14180,7 +14864,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request NilInt64 + var request float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14192,21 +14876,31 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := d.Float64() + request = float64(v) + if err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.Float{}).Validate(float64(request)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilInt64, +func (s *Server) decodeTestRequestRequiredNumberArrayRequest(r *http.Request, span trace.Span) ( + req []float64, close func() error, rerr error, ) { @@ -14236,7 +14930,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request []NilInt64 + var request []float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14248,10 +14942,12 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilInt64, 0) + request = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt64 - if err := elem.Decode(d); err != nil { + var elem float64 + v, err := d.Float64() + elem = float64(v) + if err != nil { return err } request = append(request, elem) @@ -14267,6 +14963,23 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayRequest(r *htt if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -14277,8 +14990,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilInt64, +func (s *Server) decodeTestRequestRequiredNumberArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]float64, close func() error, rerr error, ) { @@ -14308,7 +15021,7 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilInt64 + var request [][]float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14320,13 +15033,15 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilInt64, 0) + request = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt64 - elem = make([]NilInt64, 0) + var elem []float64 + elem = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt64 - if err := elemElem.Decode(d); err != nil { + var elemElem float64 + v, err := d.Float64() + elemElem = float64(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -14353,6 +15068,23 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -14374,8 +15106,8 @@ func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredNumberNullableRequest(r *http.Request, span trace.Span) ( - req NilFloat64, +func (s *Server) decodeTestRequestRequiredNumberDoubleRequest(r *http.Request, span trace.Span) ( + req float64, close func() error, rerr error, ) { @@ -14405,7 +15137,7 @@ func (s *Server) decodeTestRequestRequiredNumberNullableRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request NilFloat64 + var request float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14417,7 +15149,9 @@ func (s *Server) decodeTestRequestRequiredNumberNullableRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := d.Float64() + request = float64(v) + if err != nil { return err } return nil @@ -14425,7 +15159,7 @@ func (s *Server) decodeTestRequestRequiredNumberNullableRequest(r *http.Request, return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { - if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + if err := (validate.Float{}).Validate(float64(request)); err != nil { return errors.Wrap(err, "float") } return nil @@ -14438,8 +15172,8 @@ func (s *Server) decodeTestRequestRequiredNumberNullableRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredNumberNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilFloat64, +func (s *Server) decodeTestRequestRequiredNumberDoubleArrayRequest(r *http.Request, span trace.Span) ( + req []float64, close func() error, rerr error, ) { @@ -14469,7 +15203,7 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request []NilFloat64 + var request []float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14481,10 +15215,12 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilFloat64, 0) + request = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilFloat64 - if err := elem.Decode(d); err != nil { + var elem float64 + v, err := d.Float64() + elem = float64(v) + if err != nil { return err } request = append(request, elem) @@ -14503,7 +15239,7 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayRequest(r *http.Req var failures []validate.FieldError for i, elem := range request { if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { return errors.Wrap(err, "float") } return nil @@ -14527,8 +15263,8 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredNumberNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilFloat64, +func (s *Server) decodeTestRequestRequiredNumberDoubleArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]float64, close func() error, rerr error, ) { @@ -14558,7 +15294,7 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request [][]NilFloat64 + var request [][]float64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14570,13 +15306,15 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilFloat64, 0) + request = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilFloat64 - elem = make([]NilFloat64, 0) + var elem []float64 + elem = make([]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilFloat64 - if err := elemElem.Decode(d); err != nil { + var elemElem float64 + v, err := d.Float64() + elemElem = float64(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -14606,7 +15344,7 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayArrayRequest(r *htt var failures []validate.FieldError for i, elem := range elem { if err := func() error { - if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { return errors.Wrap(err, "float") } return nil @@ -14641,8 +15379,8 @@ func (s *Server) decodeTestRequestRequiredNumberNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestRequiredNumberDoubleNullableRequest(r *http.Request, span trace.Span) ( + req NilFloat64, close func() error, rerr error, ) { @@ -14672,7 +15410,7 @@ func (s *Server) decodeTestRequestRequiredStringRequest(r *http.Request, span tr return req, close, validate.ErrBodyRequired } - var request string + var request NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14684,23 +15422,29 @@ func (s *Server) decodeTestRequestRequiredStringRequest(r *http.Request, span tr d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilFloat64, close func() error, rerr error, ) { @@ -14730,7 +15474,7 @@ func (s *Server) decodeTestRequestRequiredStringArrayRequest(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request []string + var request []NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14742,12 +15486,10 @@ func (s *Server) decodeTestRequestRequiredStringArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { + var elem NilFloat64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -14763,6 +15505,23 @@ func (s *Server) decodeTestRequestRequiredStringArrayRequest(r *http.Request, sp if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -14773,8 +15532,8 @@ func (s *Server) decodeTestRequestRequiredStringArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestRequiredStringArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredNumberDoubleNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilFloat64, close func() error, rerr error, ) { @@ -14804,7 +15563,7 @@ func (s *Server) decodeTestRequestRequiredStringArrayArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request [][]string + var request [][]NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14816,15 +15575,13 @@ func (s *Server) decodeTestRequestRequiredStringArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []NilFloat64 + elem = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) - if err != nil { + var elemElem NilFloat64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -14851,6 +15608,23 @@ func (s *Server) decodeTestRequestRequiredStringArrayArrayRequest(r *http.Reques if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -14872,8 +15646,8 @@ func (s *Server) decodeTestRequestRequiredStringArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredStringBinaryRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestRequiredNumberFloatRequest(r *http.Request, span trace.Span) ( + req float32, close func() error, rerr error, ) { @@ -14903,7 +15677,7 @@ func (s *Server) decodeTestRequestRequiredStringBinaryRequest(r *http.Request, s return req, close, validate.ErrBodyRequired } - var request string + var request float32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14915,8 +15689,8 @@ func (s *Server) decodeTestRequestRequiredStringBinaryRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) + v, err := d.Float32() + request = float32(v) if err != nil { return err } @@ -14924,14 +15698,22 @@ func (s *Server) decodeTestRequestRequiredStringBinaryRequest(r *http.Request, s }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.Float{}).Validate(float64(request)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringBinaryArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestRequiredNumberFloatArrayRequest(r *http.Request, span trace.Span) ( + req []float32, close func() error, rerr error, ) { @@ -14961,7 +15743,7 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayRequest(r *http.Reque return req, close, validate.ErrBodyRequired } - var request []string + var request []float32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -14973,11 +15755,11 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) + var elem float32 + v, err := d.Float32() + elem = float32(v) if err != nil { return err } @@ -14994,6 +15776,23 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayRequest(r *http.Reque if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -15004,8 +15803,8 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredStringBinaryArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredNumberFloatArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]float32, close func() error, rerr error, ) { @@ -15035,7 +15834,7 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayArrayRequest(r *http. return req, close, validate.ErrBodyRequired } - var request [][]string + var request [][]float32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15047,14 +15846,14 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []float32 + elem = make([]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) + var elemElem float32 + v, err := d.Float32() + elemElem = float32(v) if err != nil { return err } @@ -15082,6 +15881,23 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayArrayRequest(r *http. if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -15103,8 +15919,8 @@ func (s *Server) decodeTestRequestRequiredStringBinaryArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringBinaryNullableRequest(r *http.Request, span trace.Span) ( - req NilString, +func (s *Server) decodeTestRequestRequiredNumberFloatNullableRequest(r *http.Request, span trace.Span) ( + req NilFloat32, close func() error, rerr error, ) { @@ -15134,7 +15950,7 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request NilString + var request NilFloat32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15153,14 +15969,22 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableRequest(r *http.Re }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilFloat32, close func() error, rerr error, ) { @@ -15190,7 +16014,7 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request []NilString + var request []NilFloat32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15202,9 +16026,9 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]NilFloat32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString + var elem NilFloat32 if err := elem.Decode(d); err != nil { return err } @@ -15221,6 +16045,23 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayRequest(r *ht if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -15231,8 +16072,8 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestRequiredNumberFloatNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilFloat32, close func() error, rerr error, ) { @@ -15262,7 +16103,7 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest( return req, close, validate.ErrBodyRequired } - var request [][]NilString + var request [][]NilFloat32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15274,12 +16115,12 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest( d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]NilFloat32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []NilFloat32 + elem = make([]NilFloat32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString + var elemElem NilFloat32 if err := elemElem.Decode(d); err != nil { return err } @@ -15307,6 +16148,23 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest( if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -15328,8 +16186,8 @@ func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest( } } -func (s *Server) decodeTestRequestRequiredStringByteRequest(r *http.Request, span trace.Span) ( - req []byte, +func (s *Server) decodeTestRequestRequiredNumberInt32Request(r *http.Request, span trace.Span) ( + req int32, close func() error, rerr error, ) { @@ -15359,7 +16217,7 @@ func (s *Server) decodeTestRequestRequiredStringByteRequest(r *http.Request, spa return req, close, validate.ErrBodyRequired } - var request []byte + var request int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15371,8 +16229,8 @@ func (s *Server) decodeTestRequestRequiredStringByteRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Base64() - request = []byte(v) + v, err := d.Int32() + request = int32(v) if err != nil { return err } @@ -15386,8 +16244,8 @@ func (s *Server) decodeTestRequestRequiredStringByteRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestRequiredStringByteArrayRequest(r *http.Request, span trace.Span) ( - req [][]byte, +func (s *Server) decodeTestRequestRequiredNumberInt32ArrayRequest(r *http.Request, span trace.Span) ( + req []int32, close func() error, rerr error, ) { @@ -15417,7 +16275,7 @@ func (s *Server) decodeTestRequestRequiredStringByteArrayRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request [][]byte + var request []int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15429,11 +16287,11 @@ func (s *Server) decodeTestRequestRequiredStringByteArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]byte, 0) + request = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []byte - v, err := d.Base64() - elem = []byte(v) + var elem int32 + v, err := d.Int32() + elem = int32(v) if err != nil { return err } @@ -15460,8 +16318,8 @@ func (s *Server) decodeTestRequestRequiredStringByteArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringByteArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][][]byte, +func (s *Server) decodeTestRequestRequiredNumberInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int32, close func() error, rerr error, ) { @@ -15491,7 +16349,7 @@ func (s *Server) decodeTestRequestRequiredStringByteArrayArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request [][][]byte + var request [][]int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15503,14 +16361,14 @@ func (s *Server) decodeTestRequestRequiredStringByteArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][][]byte, 0) + request = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem [][]byte - elem = make([][]byte, 0) + var elem []int32 + elem = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem []byte - v, err := d.Base64() - elemElem = []byte(v) + var elemElem int32 + v, err := d.Int32() + elemElem = int32(v) if err != nil { return err } @@ -15559,8 +16417,8 @@ func (s *Server) decodeTestRequestRequiredStringByteArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringByteNullableRequest(r *http.Request, span trace.Span) ( - req []byte, +func (s *Server) decodeTestRequestRequiredNumberInt32NullableRequest(r *http.Request, span trace.Span) ( + req NilInt32, close func() error, rerr error, ) { @@ -15590,7 +16448,7 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request []byte + var request NilInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15602,9 +16460,7 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Base64() - request = []byte(v) - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -15617,8 +16473,8 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringByteNullableArrayRequest(r *http.Request, span trace.Span) ( - req [][]byte, +func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilInt32, close func() error, rerr error, ) { @@ -15648,7 +16504,7 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableArrayRequest(r *http return req, close, validate.ErrBodyRequired } - var request [][]byte + var request []NilInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15660,12 +16516,10 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]byte, 0) + request = make([]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []byte - v, err := d.Base64() - elem = []byte(v) - if err != nil { + var elem NilInt32 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -15691,8 +16545,8 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringByteNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][][]byte, +func (s *Server) decodeTestRequestRequiredNumberInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilInt32, close func() error, rerr error, ) { @@ -15722,7 +16576,7 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][][]byte + var request [][]NilInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15734,15 +16588,13 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][][]byte, 0) + request = make([][]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem [][]byte - elem = make([][]byte, 0) + var elem []NilInt32 + elem = make([]NilInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem []byte - v, err := d.Base64() - elemElem = []byte(v) - if err != nil { + var elemElem NilInt32 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -15790,8 +16642,8 @@ func (s *Server) decodeTestRequestRequiredStringByteNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringDateRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredNumberInt64Request(r *http.Request, span trace.Span) ( + req int64, close func() error, rerr error, ) { @@ -15821,7 +16673,7 @@ func (s *Server) decodeTestRequestRequiredStringDateRequest(r *http.Request, spa return req, close, validate.ErrBodyRequired } - var request time.Time + var request int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15833,8 +16685,8 @@ func (s *Server) decodeTestRequestRequiredStringDateRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeDate(d) - request = v + v, err := d.Int64() + request = int64(v) if err != nil { return err } @@ -15848,8 +16700,8 @@ func (s *Server) decodeTestRequestRequiredStringDateRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestRequiredStringDateArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredNumberInt64ArrayRequest(r *http.Request, span trace.Span) ( + req []int64, close func() error, rerr error, ) { @@ -15879,7 +16731,7 @@ func (s *Server) decodeTestRequestRequiredStringDateArrayRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15891,11 +16743,11 @@ func (s *Server) decodeTestRequestRequiredStringDateArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeDate(d) - elem = v + var elem int64 + v, err := d.Int64() + elem = int64(v) if err != nil { return err } @@ -15922,8 +16774,8 @@ func (s *Server) decodeTestRequestRequiredStringDateArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringDateArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredNumberInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int64, close func() error, rerr error, ) { @@ -15953,7 +16805,7 @@ func (s *Server) decodeTestRequestRequiredStringDateArrayArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -15965,14 +16817,14 @@ func (s *Server) decodeTestRequestRequiredStringDateArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []int64 + elem = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeDate(d) - elemElem = v + var elemElem int64 + v, err := d.Int64() + elemElem = int64(v) if err != nil { return err } @@ -16021,8 +16873,8 @@ func (s *Server) decodeTestRequestRequiredStringDateArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringDateNullableRequest(r *http.Request, span trace.Span) ( - req NilDate, +func (s *Server) decodeTestRequestRequiredNumberInt64NullableRequest(r *http.Request, span trace.Span) ( + req NilInt64, close func() error, rerr error, ) { @@ -16052,7 +16904,7 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request NilDate + var request NilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16064,7 +16916,7 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeDate); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -16077,8 +16929,8 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringDateNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilDate, +func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilInt64, close func() error, rerr error, ) { @@ -16108,7 +16960,7 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableArrayRequest(r *http return req, close, validate.ErrBodyRequired } - var request []NilDate + var request []NilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16120,10 +16972,10 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilDate, 0) + request = make([]NilInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilDate - if err := elem.Decode(d, json.DecodeDate); err != nil { + var elem NilInt64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -16149,8 +17001,8 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringDateNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilDate, +func (s *Server) decodeTestRequestRequiredNumberInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilInt64, close func() error, rerr error, ) { @@ -16180,7 +17032,7 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilDate + var request [][]NilInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16192,13 +17044,13 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilDate, 0) + request = make([][]NilInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilDate - elem = make([]NilDate, 0) + var elem []NilInt64 + elem = make([]NilInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilDate - if err := elemElem.Decode(d, json.DecodeDate); err != nil { + var elemElem NilInt64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -16246,8 +17098,8 @@ func (s *Server) decodeTestRequestRequiredStringDateNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringDateTimeRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredNumberNullableRequest(r *http.Request, span trace.Span) ( + req NilFloat64, close func() error, rerr error, ) { @@ -16277,7 +17129,7 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request time.Time + var request NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16289,23 +17141,29 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeDateTime(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.Float{}).Validate(float64(request.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringDateTimeArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredNumberNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilFloat64, close func() error, rerr error, ) { @@ -16335,7 +17193,7 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16347,12 +17205,10 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeDateTime(d) - elem = v - if err != nil { + var elem NilFloat64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -16368,6 +17224,23 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayRequest(r *http.Req if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -16378,8 +17251,8 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredNumberNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilFloat64, close func() error, rerr error, ) { @@ -16409,7 +17282,7 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]NilFloat64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16421,15 +17294,13 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilFloat64 + elem = make([]NilFloat64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeDateTime(d) - elemElem = v - if err != nil { + var elemElem NilFloat64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -16456,6 +17327,23 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r *htt if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem.Value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -16477,8 +17365,8 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringDateTimeNullableRequest(r *http.Request, span trace.Span) ( - req NilDateTime, +func (s *Server) decodeTestRequestRequiredStringRequest(r *http.Request, span trace.Span) ( + req string, close func() error, rerr error, ) { @@ -16508,7 +17396,7 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableRequest(r *http. return req, close, validate.ErrBodyRequired } - var request NilDateTime + var request string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16520,7 +17408,9 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeDateTime); err != nil { + v, err := d.Str() + request = string(v) + if err != nil { return err } return nil @@ -16533,8 +17423,8 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilDateTime, +func (s *Server) decodeTestRequestRequiredStringArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -16564,7 +17454,7 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayRequest(r * return req, close, validate.ErrBodyRequired } - var request []NilDateTime + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16576,10 +17466,12 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayRequest(r * d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilDateTime, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilDateTime - if err := elem.Decode(d, json.DecodeDateTime); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } request = append(request, elem) @@ -16605,8 +17497,8 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilDateTime, +func (s *Server) decodeTestRequestRequiredStringArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -16636,7 +17528,7 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayArrayReques return req, close, validate.ErrBodyRequired } - var request [][]NilDateTime + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16648,13 +17540,15 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayArrayReques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilDateTime, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilDateTime - elem = make([]NilDateTime, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilDateTime - if err := elemElem.Decode(d, json.DecodeDateTime); err != nil { + var elemElem string + v, err := d.Str() + elemElem = string(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -16702,8 +17596,8 @@ func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayArrayReques } } -func (s *Server) decodeTestRequestRequiredStringDurationRequest(r *http.Request, span trace.Span) ( - req time.Duration, +func (s *Server) decodeTestRequestRequiredStringBinaryRequest(r *http.Request, span trace.Span) ( + req string, close func() error, rerr error, ) { @@ -16733,7 +17627,7 @@ func (s *Server) decodeTestRequestRequiredStringDurationRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request time.Duration + var request string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16745,8 +17639,8 @@ func (s *Server) decodeTestRequestRequiredStringDurationRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeDuration(d) - request = v + v, err := d.Str() + request = string(v) if err != nil { return err } @@ -16760,8 +17654,8 @@ func (s *Server) decodeTestRequestRequiredStringDurationRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredStringDurationArrayRequest(r *http.Request, span trace.Span) ( - req []time.Duration, +func (s *Server) decodeTestRequestRequiredStringBinaryArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -16791,7 +17685,7 @@ func (s *Server) decodeTestRequestRequiredStringDurationArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request []time.Duration + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16803,11 +17697,11 @@ func (s *Server) decodeTestRequestRequiredStringDurationArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Duration, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Duration - v, err := json.DecodeDuration(d) - elem = v + var elem string + v, err := d.Str() + elem = string(v) if err != nil { return err } @@ -16834,8 +17728,8 @@ func (s *Server) decodeTestRequestRequiredStringDurationArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringDurationArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Duration, +func (s *Server) decodeTestRequestRequiredStringBinaryArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -16865,7 +17759,7 @@ func (s *Server) decodeTestRequestRequiredStringDurationArrayArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request [][]time.Duration + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16877,14 +17771,14 @@ func (s *Server) decodeTestRequestRequiredStringDurationArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Duration, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Duration - elem = make([]time.Duration, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Duration - v, err := json.DecodeDuration(d) - elemElem = v + var elemElem string + v, err := d.Str() + elemElem = string(v) if err != nil { return err } @@ -16933,8 +17827,8 @@ func (s *Server) decodeTestRequestRequiredStringDurationArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringDurationNullableRequest(r *http.Request, span trace.Span) ( - req NilDuration, +func (s *Server) decodeTestRequestRequiredStringBinaryNullableRequest(r *http.Request, span trace.Span) ( + req NilString, close func() error, rerr error, ) { @@ -16964,7 +17858,7 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableRequest(r *http. return req, close, validate.ErrBodyRequired } - var request NilDuration + var request NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -16989,8 +17883,8 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilDuration, +func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -17020,7 +17914,7 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayRequest(r * return req, close, validate.ErrBodyRequired } - var request []NilDuration + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17032,9 +17926,9 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayRequest(r * d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilDuration, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilDuration + var elem NilString if err := elem.Decode(d); err != nil { return err } @@ -17061,8 +17955,8 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilDuration, +func (s *Server) decodeTestRequestRequiredStringBinaryNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -17092,7 +17986,7 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayArrayReques return req, close, validate.ErrBodyRequired } - var request [][]NilDuration + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17104,12 +17998,12 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayArrayReques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilDuration, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilDuration - elem = make([]NilDuration, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilDuration + var elemElem NilString if err := elemElem.Decode(d); err != nil { return err } @@ -17158,8 +18052,8 @@ func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayArrayReques } } -func (s *Server) decodeTestRequestRequiredStringEmailRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestRequiredStringByteRequest(r *http.Request, span trace.Span) ( + req []byte, close func() error, rerr error, ) { @@ -17189,7 +18083,7 @@ func (s *Server) decodeTestRequestRequiredStringEmailRequest(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request string + var request []byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17201,8 +18095,8 @@ func (s *Server) decodeTestRequestRequiredStringEmailRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) + v, err := d.Base64() + request = []byte(v) if err != nil { return err } @@ -17210,30 +18104,14 @@ func (s *Server) decodeTestRequestRequiredStringEmailRequest(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringEmailArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestRequiredStringByteArrayRequest(r *http.Request, span trace.Span) ( + req [][]byte, close func() error, rerr error, ) { @@ -17263,7 +18141,7 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request []string + var request [][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17275,11 +18153,11 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) + var elem []byte + v, err := d.Base64() + elem = []byte(v) if err != nil { return err } @@ -17296,31 +18174,6 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayRequest(r *http.Reques if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -17331,8 +18184,8 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredStringEmailArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredStringByteArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][][]byte, close func() error, rerr error, ) { @@ -17362,7 +18215,7 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request [][]string + var request [][][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17374,14 +18227,14 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem [][]byte + elem = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) + var elemElem []byte + v, err := d.Base64() + elemElem = []byte(v) if err != nil { return err } @@ -17409,31 +18262,6 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -17455,8 +18283,8 @@ func (s *Server) decodeTestRequestRequiredStringEmailArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredStringEmailNullableRequest(r *http.Request, span trace.Span) ( - req NilString, +func (s *Server) decodeTestRequestRequiredStringByteNullableRequest(r *http.Request, span trace.Span) ( + req []byte, close func() error, rerr error, ) { @@ -17486,7 +18314,7 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request NilString + var request []byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17498,37 +18326,23 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := d.Base64() + request = []byte(v) + if err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestRequiredStringByteNullableArrayRequest(r *http.Request, span trace.Span) ( + req [][]byte, close func() error, rerr error, ) { @@ -17558,7 +18372,7 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request []NilString + var request [][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17570,10 +18384,12 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem []byte + v, err := d.Base64() + elem = []byte(v) + if err != nil { return err } request = append(request, elem) @@ -17589,31 +18405,6 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayRequest(r *htt if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -17624,8 +18415,8 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestRequiredStringByteNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][][]byte, close func() error, rerr error, ) { @@ -17655,7 +18446,7 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilString + var request [][][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17667,13 +18458,15 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem [][]byte + elem = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem []byte + v, err := d.Base64() + elemElem = []byte(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -17700,31 +18493,6 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -17746,8 +18514,8 @@ func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringHostnameRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestRequiredStringDateRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -17777,7 +18545,7 @@ func (s *Server) decodeTestRequestRequiredStringHostnameRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request string + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17789,8 +18557,8 @@ func (s *Server) decodeTestRequestRequiredStringHostnameRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) + v, err := json.DecodeDate(d) + request = v if err != nil { return err } @@ -17798,30 +18566,14 @@ func (s *Server) decodeTestRequestRequiredStringHostnameRequest(r *http.Request, }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringHostnameArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestRequiredStringDateArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -17851,7 +18603,7 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request []string + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17863,11 +18615,11 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) + var elem time.Time + v, err := json.DecodeDate(d) + elem = v if err != nil { return err } @@ -17884,31 +18636,6 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayRequest(r *http.Req if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -17919,8 +18646,8 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringHostnameArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredStringDateArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -17950,7 +18677,7 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request [][]string + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -17962,14 +18689,14 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) + var elemElem time.Time + v, err := json.DecodeDate(d) + elemElem = v if err != nil { return err } @@ -17997,31 +18724,6 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayArrayRequest(r *htt if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -18043,8 +18745,8 @@ func (s *Server) decodeTestRequestRequiredStringHostnameArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringHostnameNullableRequest(r *http.Request, span trace.Span) ( - req NilString, +func (s *Server) decodeTestRequestRequiredStringDateNullableRequest(r *http.Request, span trace.Span) ( + req NilDate, close func() error, rerr error, ) { @@ -18074,7 +18776,7 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableRequest(r *http. return req, close, validate.ErrBodyRequired } - var request NilString + var request NilDate buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18086,37 +18788,21 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeDate); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestRequiredStringDateNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilDate, close func() error, rerr error, ) { @@ -18146,7 +18832,7 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayRequest(r * return req, close, validate.ErrBodyRequired } - var request []NilString + var request []NilDate buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18158,10 +18844,10 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayRequest(r * d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]NilDate, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem NilDate + if err := elem.Decode(d, json.DecodeDate); err != nil { return err } request = append(request, elem) @@ -18177,31 +18863,6 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayRequest(r * if request == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -18212,8 +18873,8 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestRequiredStringDateNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilDate, close func() error, rerr error, ) { @@ -18243,7 +18904,7 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayArrayReques return req, close, validate.ErrBodyRequired } - var request [][]NilString + var request [][]NilDate buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18255,13 +18916,13 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayArrayReques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]NilDate, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []NilDate + elem = make([]NilDate, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem NilDate + if err := elemElem.Decode(d, json.DecodeDate); err != nil { return err } elem = append(elem, elemElem) @@ -18288,31 +18949,6 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayArrayReques if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -18334,8 +18970,8 @@ func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayArrayReques } } -func (s *Server) decodeTestRequestRequiredStringIPRequest(r *http.Request, span trace.Span) ( - req netip.Addr, +func (s *Server) decodeTestRequestRequiredStringDateTimeRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -18365,7 +19001,7 @@ func (s *Server) decodeTestRequestRequiredStringIPRequest(r *http.Request, span return req, close, validate.ErrBodyRequired } - var request netip.Addr + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18377,7 +19013,7 @@ func (s *Server) decodeTestRequestRequiredStringIPRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeIP(d) + v, err := json.DecodeDateTime(d) request = v if err != nil { return err @@ -18392,8 +19028,8 @@ func (s *Server) decodeTestRequestRequiredStringIPRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestRequiredStringIPArrayRequest(r *http.Request, span trace.Span) ( - req []netip.Addr, +func (s *Server) decodeTestRequestRequiredStringDateTimeArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -18423,7 +19059,7 @@ func (s *Server) decodeTestRequestRequiredStringIPArrayRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request []netip.Addr + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18435,10 +19071,10 @@ func (s *Server) decodeTestRequestRequiredStringIPArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([]netip.Addr, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem netip.Addr - v, err := json.DecodeIP(d) + var elem time.Time + v, err := json.DecodeDateTime(d) elem = v if err != nil { return err @@ -18466,8 +19102,8 @@ func (s *Server) decodeTestRequestRequiredStringIPArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredStringIPArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]netip.Addr, +func (s *Server) decodeTestRequestRequiredStringDateTimeArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -18497,7 +19133,7 @@ func (s *Server) decodeTestRequestRequiredStringIPArrayArrayRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request [][]netip.Addr + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18509,13 +19145,13 @@ func (s *Server) decodeTestRequestRequiredStringIPArrayArrayRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]netip.Addr, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []netip.Addr - elem = make([]netip.Addr, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem netip.Addr - v, err := json.DecodeIP(d) + var elemElem time.Time + v, err := json.DecodeDateTime(d) elemElem = v if err != nil { return err @@ -18565,8 +19201,8 @@ func (s *Server) decodeTestRequestRequiredStringIPArrayArrayRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringIPNullableRequest(r *http.Request, span trace.Span) ( - req NilIP, +func (s *Server) decodeTestRequestRequiredStringDateTimeNullableRequest(r *http.Request, span trace.Span) ( + req NilDateTime, close func() error, rerr error, ) { @@ -18596,7 +19232,7 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request NilIP + var request NilDateTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18608,7 +19244,7 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeDateTime); err != nil { return err } return nil @@ -18621,8 +19257,8 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredStringIPNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilIP, +func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilDateTime, close func() error, rerr error, ) { @@ -18652,7 +19288,7 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request []NilIP + var request []NilDateTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18664,10 +19300,10 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilIP, 0) + request = make([]NilDateTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIP - if err := elem.Decode(d); err != nil { + var elem NilDateTime + if err := elem.Decode(d, json.DecodeDateTime); err != nil { return err } request = append(request, elem) @@ -18693,8 +19329,8 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredStringIPNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilIP, +func (s *Server) decodeTestRequestRequiredStringDateTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilDateTime, close func() error, rerr error, ) { @@ -18724,7 +19360,7 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableArrayArrayRequest(r *h return req, close, validate.ErrBodyRequired } - var request [][]NilIP + var request [][]NilDateTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18736,13 +19372,13 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableArrayArrayRequest(r *h d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilIP, 0) + request = make([][]NilDateTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIP - elem = make([]NilIP, 0) + var elem []NilDateTime + elem = make([]NilDateTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIP - if err := elemElem.Decode(d); err != nil { + var elemElem NilDateTime + if err := elemElem.Decode(d, json.DecodeDateTime); err != nil { return err } elem = append(elem, elemElem) @@ -18790,8 +19426,8 @@ func (s *Server) decodeTestRequestRequiredStringIPNullableArrayArrayRequest(r *h } } -func (s *Server) decodeTestRequestRequiredStringInt32Request(r *http.Request, span trace.Span) ( - req int32, +func (s *Server) decodeTestRequestRequiredStringDurationRequest(r *http.Request, span trace.Span) ( + req time.Duration, close func() error, rerr error, ) { @@ -18821,7 +19457,7 @@ func (s *Server) decodeTestRequestRequiredStringInt32Request(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request int32 + var request time.Duration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18833,7 +19469,7 @@ func (s *Server) decodeTestRequestRequiredStringInt32Request(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeStringInt32(d) + v, err := json.DecodeDuration(d) request = v if err != nil { return err @@ -18848,8 +19484,8 @@ func (s *Server) decodeTestRequestRequiredStringInt32Request(r *http.Request, sp } } -func (s *Server) decodeTestRequestRequiredStringInt32ArrayRequest(r *http.Request, span trace.Span) ( - req []int32, +func (s *Server) decodeTestRequestRequiredStringDurationArrayRequest(r *http.Request, span trace.Span) ( + req []time.Duration, close func() error, rerr error, ) { @@ -18879,7 +19515,7 @@ func (s *Server) decodeTestRequestRequiredStringInt32ArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request []int32 + var request []time.Duration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18891,10 +19527,10 @@ func (s *Server) decodeTestRequestRequiredStringInt32ArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int32, 0) + request = make([]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int32 - v, err := json.DecodeStringInt32(d) + var elem time.Duration + v, err := json.DecodeDuration(d) elem = v if err != nil { return err @@ -18922,8 +19558,8 @@ func (s *Server) decodeTestRequestRequiredStringInt32ArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredStringInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int32, +func (s *Server) decodeTestRequestRequiredStringDurationArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Duration, close func() error, rerr error, ) { @@ -18953,7 +19589,7 @@ func (s *Server) decodeTestRequestRequiredStringInt32ArrayArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request [][]int32 + var request [][]time.Duration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -18965,13 +19601,13 @@ func (s *Server) decodeTestRequestRequiredStringInt32ArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int32, 0) + request = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int32 - elem = make([]int32, 0) + var elem []time.Duration + elem = make([]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int32 - v, err := json.DecodeStringInt32(d) + var elemElem time.Duration + v, err := json.DecodeDuration(d) elemElem = v if err != nil { return err @@ -19021,8 +19657,8 @@ func (s *Server) decodeTestRequestRequiredStringInt32ArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredStringInt32NullableRequest(r *http.Request, span trace.Span) ( - req NilStringInt32, +func (s *Server) decodeTestRequestRequiredStringDurationNullableRequest(r *http.Request, span trace.Span) ( + req NilDuration, close func() error, rerr error, ) { @@ -19052,7 +19688,7 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request NilStringInt32 + var request NilDuration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19077,8 +19713,8 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringInt32, +func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilDuration, close func() error, rerr error, ) { @@ -19108,7 +19744,7 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request []NilStringInt32 + var request []NilDuration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19120,9 +19756,9 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringInt32, 0) + request = make([]NilDuration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt32 + var elem NilDuration if err := elem.Decode(d); err != nil { return err } @@ -19149,8 +19785,8 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringInt32, +func (s *Server) decodeTestRequestRequiredStringDurationNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilDuration, close func() error, rerr error, ) { @@ -19180,7 +19816,7 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilStringInt32 + var request [][]NilDuration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19192,12 +19828,12 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringInt32, 0) + request = make([][]NilDuration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt32 - elem = make([]NilStringInt32, 0) + var elem []NilDuration + elem = make([]NilDuration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt32 + var elemElem NilDuration if err := elemElem.Decode(d); err != nil { return err } @@ -19246,8 +19882,8 @@ func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringInt64Request(r *http.Request, span trace.Span) ( - req int64, +func (s *Server) decodeTestRequestRequiredStringEmailRequest(r *http.Request, span trace.Span) ( + req string, close func() error, rerr error, ) { @@ -19277,7 +19913,7 @@ func (s *Server) decodeTestRequestRequiredStringInt64Request(r *http.Request, sp return req, close, validate.ErrBodyRequired } - var request int64 + var request string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19289,8 +19925,8 @@ func (s *Server) decodeTestRequestRequiredStringInt64Request(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeStringInt64(d) - request = v + v, err := d.Str() + request = string(v) if err != nil { return err } @@ -19298,14 +19934,30 @@ func (s *Server) decodeTestRequestRequiredStringInt64Request(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringInt64ArrayRequest(r *http.Request, span trace.Span) ( - req []int64, +func (s *Server) decodeTestRequestRequiredStringEmailArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -19335,7 +19987,7 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayRequest(r *http.Reques return req, close, validate.ErrBodyRequired } - var request []int64 + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19347,11 +19999,11 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int64, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int64 - v, err := json.DecodeStringInt64(d) - elem = v + var elem string + v, err := d.Str() + elem = string(v) if err != nil { return err } @@ -19368,6 +20020,31 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayRequest(r *http.Reques if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -19378,8 +20055,8 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestRequiredStringInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int64, +func (s *Server) decodeTestRequestRequiredStringEmailArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -19409,7 +20086,7 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayArrayRequest(r *http.R return req, close, validate.ErrBodyRequired } - var request [][]int64 + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19421,14 +20098,14 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int64, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int64 - elem = make([]int64, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int64 - v, err := json.DecodeStringInt64(d) - elemElem = v + var elemElem string + v, err := d.Str() + elemElem = string(v) if err != nil { return err } @@ -19456,6 +20133,31 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -19477,8 +20179,8 @@ func (s *Server) decodeTestRequestRequiredStringInt64ArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestRequiredStringInt64NullableRequest(r *http.Request, span trace.Span) ( - req NilStringInt64, +func (s *Server) decodeTestRequestRequiredStringEmailNullableRequest(r *http.Request, span trace.Span) ( + req NilString, close func() error, rerr error, ) { @@ -19508,7 +20210,7 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request NilStringInt64 + var request NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19527,14 +20229,30 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableRequest(r *http.Req }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringInt64, +func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -19564,7 +20282,7 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request []NilStringInt64 + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19576,9 +20294,9 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringInt64, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt64 + var elem NilString if err := elem.Decode(d); err != nil { return err } @@ -19595,6 +20313,31 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayRequest(r *htt if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -19605,8 +20348,8 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringInt64, +func (s *Server) decodeTestRequestRequiredStringEmailNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -19636,7 +20379,7 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilStringInt64 + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19648,12 +20391,12 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringInt64, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt64 - elem = make([]NilStringInt64, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt64 + var elemElem NilString if err := elemElem.Decode(d); err != nil { return err } @@ -19681,6 +20424,31 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -19702,8 +20470,8 @@ func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringIpv4Request(r *http.Request, span trace.Span) ( - req netip.Addr, +func (s *Server) decodeTestRequestRequiredStringHostnameRequest(r *http.Request, span trace.Span) ( + req string, close func() error, rerr error, ) { @@ -19733,7 +20501,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv4Request(r *http.Request, spa return req, close, validate.ErrBodyRequired } - var request netip.Addr + var request string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19745,8 +20513,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv4Request(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeIP(d) - request = v + v, err := d.Str() + request = string(v) if err != nil { return err } @@ -19754,14 +20522,30 @@ func (s *Server) decodeTestRequestRequiredStringIpv4Request(r *http.Request, spa }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringIpv4ArrayRequest(r *http.Request, span trace.Span) ( - req []netip.Addr, +func (s *Server) decodeTestRequestRequiredStringHostnameArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -19791,7 +20575,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request []netip.Addr + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19803,11 +20587,11 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]netip.Addr, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem netip.Addr - v, err := json.DecodeIP(d) - elem = v + var elem string + v, err := d.Str() + elem = string(v) if err != nil { return err } @@ -19824,6 +20608,31 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayRequest(r *http.Request if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -19834,8 +20643,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]netip.Addr, +func (s *Server) decodeTestRequestRequiredStringHostnameArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -19865,7 +20674,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request [][]netip.Addr + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19877,14 +20686,14 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]netip.Addr, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []netip.Addr - elem = make([]netip.Addr, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem netip.Addr - v, err := json.DecodeIP(d) - elemElem = v + var elemElem string + v, err := d.Str() + elemElem = string(v) if err != nil { return err } @@ -19912,6 +20721,31 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r *http.Re if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -19933,8 +20767,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringIpv4NullableRequest(r *http.Request, span trace.Span) ( - req NilIPv4, +func (s *Server) decodeTestRequestRequiredStringHostnameNullableRequest(r *http.Request, span trace.Span) ( + req NilString, close func() error, rerr error, ) { @@ -19964,7 +20798,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request NilIPv4 + var request NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -19983,14 +20817,30 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableRequest(r *http.Requ }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilIPv4, +func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -20020,7 +20870,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayRequest(r *http return req, close, validate.ErrBodyRequired } - var request []NilIPv4 + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20032,9 +20882,9 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilIPv4, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIPv4 + var elem NilString if err := elem.Decode(d); err != nil { return err } @@ -20051,6 +20901,31 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayRequest(r *http if request == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { return req, close, errors.Wrap(err, "validate") @@ -20061,8 +20936,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilIPv4, +func (s *Server) decodeTestRequestRequiredStringHostnameNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -20092,7 +20967,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilIPv4 + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20104,12 +20979,12 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilIPv4, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIPv4 - elem = make([]NilIPv4, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIPv4 + var elemElem NilString if err := elemElem.Decode(d); err != nil { return err } @@ -20137,6 +21012,31 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -20158,7 +21058,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringIpv6Request(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringIPRequest(r *http.Request, span trace.Span) ( req netip.Addr, close func() error, rerr error, @@ -20216,7 +21116,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv6Request(r *http.Request, spa } } -func (s *Server) decodeTestRequestRequiredStringIpv6ArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringIPArrayRequest(r *http.Request, span trace.Span) ( req []netip.Addr, close func() error, rerr error, @@ -20290,7 +21190,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv6ArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringIpv6ArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringIPArrayArrayRequest(r *http.Request, span trace.Span) ( req [][]netip.Addr, close func() error, rerr error, @@ -20389,8 +21289,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv6ArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringIpv6NullableRequest(r *http.Request, span trace.Span) ( - req NilIPv6, +func (s *Server) decodeTestRequestRequiredStringIPNullableRequest(r *http.Request, span trace.Span) ( + req NilIP, close func() error, rerr error, ) { @@ -20420,7 +21320,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request NilIPv6 + var request NilIP buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20445,8 +21345,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilIPv6, +func (s *Server) decodeTestRequestRequiredStringIPNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilIP, close func() error, rerr error, ) { @@ -20476,7 +21376,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayRequest(r *http return req, close, validate.ErrBodyRequired } - var request []NilIPv6 + var request []NilIP buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20488,9 +21388,9 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilIPv6, 0) + request = make([]NilIP, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIPv6 + var elem NilIP if err := elem.Decode(d); err != nil { return err } @@ -20517,8 +21417,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilIPv6, +func (s *Server) decodeTestRequestRequiredStringIPNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilIP, close func() error, rerr error, ) { @@ -20548,7 +21448,7 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilIPv6 + var request [][]NilIP buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20560,12 +21460,12 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilIPv6, 0) + request = make([][]NilIP, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIPv6 - elem = make([]NilIPv6, 0) + var elem []NilIP + elem = make([]NilIP, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIPv6 + var elemElem NilIP if err := elemElem.Decode(d); err != nil { return err } @@ -20614,8 +21514,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request, span trace.Span) ( - req NilString, +func (s *Server) decodeTestRequestRequiredStringInt32Request(r *http.Request, span trace.Span) ( + req int32, close func() error, rerr error, ) { @@ -20645,7 +21545,7 @@ func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request NilString + var request int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20657,7 +21557,9 @@ func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := json.DecodeStringInt32(d) + request = v + if err != nil { return err } return nil @@ -20670,8 +21572,8 @@ func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestRequiredStringInt32ArrayRequest(r *http.Request, span trace.Span) ( + req []int32, close func() error, rerr error, ) { @@ -20701,7 +21603,7 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request []NilString + var request []int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20713,10 +21615,12 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem int32 + v, err := json.DecodeStringInt32(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -20742,8 +21646,8 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestRequiredStringInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int32, close func() error, rerr error, ) { @@ -20773,7 +21677,7 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request [][]NilString + var request [][]int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20785,13 +21689,15 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []int32 + elem = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem int32 + v, err := json.DecodeStringInt32(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -20839,8 +21745,8 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestRequiredStringInt32NullableRequest(r *http.Request, span trace.Span) ( + req NilStringInt32, close func() error, rerr error, ) { @@ -20870,7 +21776,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request string + var request NilStringInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20882,9 +21788,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -20897,8 +21801,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringInt32, close func() error, rerr error, ) { @@ -20928,7 +21832,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request []string + var request []NilStringInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -20940,12 +21844,10 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { + var elem NilStringInt32 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -20971,8 +21873,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredStringInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringInt32, close func() error, rerr error, ) { @@ -21002,7 +21904,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request [][]string + var request [][]NilStringInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21014,15 +21916,13 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []NilStringInt32 + elem = make([]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) - if err != nil { + var elemElem NilStringInt32 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -21070,8 +21970,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringPasswordNullableRequest(r *http.Request, span trace.Span) ( - req NilString, +func (s *Server) decodeTestRequestRequiredStringInt64Request(r *http.Request, span trace.Span) ( + req int64, close func() error, rerr error, ) { @@ -21101,7 +22001,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableRequest(r *http. return req, close, validate.ErrBodyRequired } - var request NilString + var request int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21113,7 +22013,9 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := json.DecodeStringInt64(d) + request = v + if err != nil { return err } return nil @@ -21126,8 +22028,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestRequiredStringInt64ArrayRequest(r *http.Request, span trace.Span) ( + req []int64, close func() error, rerr error, ) { @@ -21157,7 +22059,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r * return req, close, validate.ErrBodyRequired } - var request []NilString + var request []int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21169,10 +22071,12 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r * d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem int64 + v, err := json.DecodeStringInt64(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -21198,8 +22102,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestRequiredStringInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int64, close func() error, rerr error, ) { @@ -21229,7 +22133,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayReques return req, close, validate.ErrBodyRequired } - var request [][]NilString + var request [][]int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21241,13 +22145,15 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayReques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []int64 + elem = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem int64 + v, err := json.DecodeStringInt64(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -21295,8 +22201,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayReques } } -func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredStringInt64NullableRequest(r *http.Request, span trace.Span) ( + req NilStringInt64, close func() error, rerr error, ) { @@ -21326,7 +22232,7 @@ func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request, spa return req, close, validate.ErrBodyRequired } - var request time.Time + var request NilStringInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21338,9 +22244,7 @@ func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeTime(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -21353,8 +22257,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringInt64, close func() error, rerr error, ) { @@ -21384,7 +22288,7 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []NilStringInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21396,12 +22300,10 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeTime(d) - elem = v - if err != nil { + var elem NilStringInt64 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -21427,8 +22329,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredStringInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringInt64, close func() error, rerr error, ) { @@ -21458,7 +22360,7 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]NilStringInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21470,15 +22372,13 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilStringInt64 + elem = make([]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeTime(d) - elemElem = v - if err != nil { + var elemElem NilStringInt64 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -21526,8 +22426,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Request, span trace.Span) ( - req NilTime, +func (s *Server) decodeTestRequestRequiredStringIpv4Request(r *http.Request, span trace.Span) ( + req netip.Addr, close func() error, rerr error, ) { @@ -21557,7 +22457,7 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request NilTime + var request netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21569,7 +22469,9 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeTime); err != nil { + v, err := json.DecodeIP(d) + request = v + if err != nil { return err } return nil @@ -21582,8 +22484,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilTime, +func (s *Server) decodeTestRequestRequiredStringIpv4ArrayRequest(r *http.Request, span trace.Span) ( + req []netip.Addr, close func() error, rerr error, ) { @@ -21613,7 +22515,7 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http return req, close, validate.ErrBodyRequired } - var request []NilTime + var request []netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21625,10 +22527,12 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilTime, 0) + request = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilTime - if err := elem.Decode(d, json.DecodeTime); err != nil { + var elem netip.Addr + v, err := json.DecodeIP(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -21654,8 +22558,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilTime, +func (s *Server) decodeTestRequestRequiredStringIpv4ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]netip.Addr, close func() error, rerr error, ) { @@ -21685,7 +22589,7 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilTime + var request [][]netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21697,13 +22601,15 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilTime, 0) + request = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilTime - elem = make([]NilTime, 0) + var elem []netip.Addr + elem = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilTime - if err := elemElem.Decode(d, json.DecodeTime); err != nil { + var elemElem netip.Addr + v, err := json.DecodeIP(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -21751,8 +22657,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request, span trace.Span) ( - req url.URL, +func (s *Server) decodeTestRequestRequiredStringIpv4NullableRequest(r *http.Request, span trace.Span) ( + req NilIPv4, close func() error, rerr error, ) { @@ -21782,7 +22688,7 @@ func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request, span return req, close, validate.ErrBodyRequired } - var request url.URL + var request NilIPv4 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21794,9 +22700,7 @@ func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeURI(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -21809,8 +22713,8 @@ func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request, span trace.Span) ( - req []url.URL, +func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilIPv4, close func() error, rerr error, ) { @@ -21840,7 +22744,7 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request []url.URL + var request []NilIPv4 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21852,12 +22756,10 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([]url.URL, 0) + request = make([]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem url.URL - v, err := json.DecodeURI(d) - elem = v - if err != nil { + var elem NilIPv4 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -21883,8 +22785,8 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]url.URL, +func (s *Server) decodeTestRequestRequiredStringIpv4NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilIPv4, close func() error, rerr error, ) { @@ -21914,7 +22816,7 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request [][]url.URL + var request [][]NilIPv4 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -21926,15 +22828,13 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]url.URL, 0) + request = make([][]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []url.URL - elem = make([]url.URL, 0) + var elem []NilIPv4 + elem = make([]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem url.URL - v, err := json.DecodeURI(d) - elemElem = v - if err != nil { + var elemElem NilIPv4 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -21982,8 +22882,8 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Request, span trace.Span) ( - req NilURI, +func (s *Server) decodeTestRequestRequiredStringIpv6Request(r *http.Request, span trace.Span) ( + req netip.Addr, close func() error, rerr error, ) { @@ -22013,7 +22913,7 @@ func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Reque return req, close, validate.ErrBodyRequired } - var request NilURI + var request netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22025,7 +22925,9 @@ func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d); err != nil { + v, err := json.DecodeIP(d) + request = v + if err != nil { return err } return nil @@ -22038,8 +22940,8 @@ func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilURI, +func (s *Server) decodeTestRequestRequiredStringIpv6ArrayRequest(r *http.Request, span trace.Span) ( + req []netip.Addr, close func() error, rerr error, ) { @@ -22069,7 +22971,7 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http. return req, close, validate.ErrBodyRequired } - var request []NilURI + var request []netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22081,10 +22983,12 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilURI, 0) + request = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilURI - if err := elem.Decode(d); err != nil { + var elem netip.Addr + v, err := json.DecodeIP(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -22110,8 +23014,8 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilURI, +func (s *Server) decodeTestRequestRequiredStringIpv6ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]netip.Addr, close func() error, rerr error, ) { @@ -22141,7 +23045,7 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r * return req, close, validate.ErrBodyRequired } - var request [][]NilURI + var request [][]netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22153,13 +23057,15 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r * d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilURI, 0) + request = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilURI - elem = make([]NilURI, 0) + var elem []netip.Addr + elem = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilURI - if err := elemElem.Decode(d); err != nil { + var elemElem netip.Addr + v, err := json.DecodeIP(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -22207,8 +23113,8 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request, span trace.Span) ( - req uuid.UUID, +func (s *Server) decodeTestRequestRequiredStringIpv6NullableRequest(r *http.Request, span trace.Span) ( + req NilIPv6, close func() error, rerr error, ) { @@ -22238,7 +23144,7 @@ func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request, spa return req, close, validate.ErrBodyRequired } - var request uuid.UUID + var request NilIPv6 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22250,9 +23156,7 @@ func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeUUID(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -22265,8 +23169,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request, span trace.Span) ( - req []uuid.UUID, +func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilIPv6, close func() error, rerr error, ) { @@ -22296,7 +23200,7 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request []uuid.UUID + var request []NilIPv6 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22308,12 +23212,10 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]uuid.UUID, 0) + request = make([]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uuid.UUID - v, err := json.DecodeUUID(d) - elem = v - if err != nil { + var elem NilIPv6 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -22339,8 +23241,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]uuid.UUID, +func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilIPv6, close func() error, rerr error, ) { @@ -22370,7 +23272,7 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request [][]uuid.UUID + var request [][]NilIPv6 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22382,15 +23284,13 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]uuid.UUID, 0) + request = make([][]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uuid.UUID - elem = make([]uuid.UUID, 0) + var elem []NilIPv6 + elem = make([]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uuid.UUID - v, err := json.DecodeUUID(d) - elemElem = v - if err != nil { + var elemElem NilIPv6 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -22438,8 +23338,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringUUIDNullableRequest(r *http.Request, span trace.Span) ( - req NilUUID, +func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request, span trace.Span) ( + req NilString, close func() error, rerr error, ) { @@ -22469,7 +23369,7 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request NilUUID + var request NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22494,8 +23394,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUUID, +func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -22525,7 +23425,7 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayRequest(r *http return req, close, validate.ErrBodyRequired } - var request []NilUUID + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22537,9 +23437,9 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUUID, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUUID + var elem NilString if err := elem.Decode(d); err != nil { return err } @@ -22566,8 +23466,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUUID, +func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -22597,7 +23497,7 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilUUID + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22609,12 +23509,12 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUUID, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUUID - elem = make([]NilUUID, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUUID + var elemElem NilString if err := elemElem.Decode(d); err != nil { return err } @@ -22663,8 +23563,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringUnixRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request, span trace.Span) ( + req string, close func() error, rerr error, ) { @@ -22694,7 +23594,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixRequest(r *http.Request, spa return req, close, validate.ErrBodyRequired } - var request time.Time + var request string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22706,8 +23606,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeStringUnixSeconds(d) - request = v + v, err := d.Str() + request = string(v) if err != nil { return err } @@ -22721,8 +23621,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestRequiredStringUnixArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -22752,7 +23652,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixArrayRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22764,11 +23664,11 @@ func (s *Server) decodeTestRequestRequiredStringUnixArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixSeconds(d) - elem = v + var elem string + v, err := d.Str() + elem = string(v) if err != nil { return err } @@ -22795,8 +23695,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringUnixArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -22826,7 +23726,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixArrayArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22838,14 +23738,14 @@ func (s *Server) decodeTestRequestRequiredStringUnixArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixSeconds(d) - elemElem = v + var elemElem string + v, err := d.Str() + elemElem = string(v) if err != nil { return err } @@ -22894,8 +23794,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringUnixMicroRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordNullableRequest(r *http.Request, span trace.Span) ( + req NilString, close func() error, rerr error, ) { @@ -22925,7 +23825,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request time.Time + var request NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22937,9 +23837,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeStringUnixMicro(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -22952,8 +23850,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -22983,7 +23881,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -22995,12 +23893,10 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixMicro(d) - elem = v - if err != nil { + var elem NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -23026,8 +23922,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -23057,7 +23953,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23069,15 +23965,13 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixMicro(d) - elemElem = v - if err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -23125,8 +24019,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableRequest(r *http.Request, span trace.Span) ( - req NilStringUnixMicro, +func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -23156,7 +24050,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableRequest(r *http return req, close, validate.ErrBodyRequired } - var request NilStringUnixMicro + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23168,7 +24062,9 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { + v, err := json.DecodeTime(d) + request = v + if err != nil { return err } return nil @@ -23181,8 +24077,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixMicro, +func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -23212,7 +24108,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r return req, close, validate.ErrBodyRequired } - var request []NilStringUnixMicro + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23224,10 +24120,12 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixMicro, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixMicro - if err := elem.Decode(d, json.DecodeStringUnixMicro); err != nil { + var elem time.Time + v, err := json.DecodeTime(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -23253,8 +24151,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixMicro, +func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -23284,7 +24182,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayArrayReque return req, close, validate.ErrBodyRequired } - var request [][]NilStringUnixMicro + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23296,13 +24194,15 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayArrayReque d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixMicro, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixMicro - elem = make([]NilStringUnixMicro, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixMicro - if err := elemElem.Decode(d, json.DecodeStringUnixMicro); err != nil { + var elemElem time.Time + v, err := json.DecodeTime(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -23350,8 +24250,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayArrayReque } } -func (s *Server) decodeTestRequestRequiredStringUnixMilliRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Request, span trace.Span) ( + req NilTime, close func() error, rerr error, ) { @@ -23381,7 +24281,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliRequest(r *http.Request return req, close, validate.ErrBodyRequired } - var request time.Time + var request NilTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23393,9 +24293,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeStringUnixMilli(d) - request = v - if err != nil { + if err := request.Decode(d, json.DecodeTime); err != nil { return err } return nil @@ -23408,8 +24306,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilTime, close func() error, rerr error, ) { @@ -23439,7 +24337,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayRequest(r *http.Re return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []NilTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23451,12 +24349,10 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixMilli(d) - elem = v - if err != nil { + var elem NilTime + if err := elem.Decode(d, json.DecodeTime); err != nil { return err } request = append(request, elem) @@ -23482,8 +24378,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilTime, close func() error, rerr error, ) { @@ -23513,7 +24409,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r *ht return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]NilTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23525,15 +24421,13 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilTime + elem = make([]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixMilli(d) - elemElem = v - if err != nil { + var elemElem NilTime + if err := elemElem.Decode(d, json.DecodeTime); err != nil { return err } elem = append(elem, elemElem) @@ -23581,8 +24475,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableRequest(r *http.Request, span trace.Span) ( - req NilStringUnixMilli, +func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request, span trace.Span) ( + req url.URL, close func() error, rerr error, ) { @@ -23612,7 +24506,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableRequest(r *http return req, close, validate.ErrBodyRequired } - var request NilStringUnixMilli + var request url.URL buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23624,7 +24518,9 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { + v, err := json.DecodeURI(d) + request = v + if err != nil { return err } return nil @@ -23637,8 +24533,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixMilli, +func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request, span trace.Span) ( + req []url.URL, close func() error, rerr error, ) { @@ -23668,7 +24564,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r return req, close, validate.ErrBodyRequired } - var request []NilStringUnixMilli + var request []url.URL buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23680,10 +24576,12 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixMilli, 0) + request = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixMilli - if err := elem.Decode(d, json.DecodeStringUnixMilli); err != nil { + var elem url.URL + v, err := json.DecodeURI(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -23709,8 +24607,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixMilli, +func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]url.URL, close func() error, rerr error, ) { @@ -23740,7 +24638,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayArrayReque return req, close, validate.ErrBodyRequired } - var request [][]NilStringUnixMilli + var request [][]url.URL buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23752,13 +24650,15 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayArrayReque d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixMilli, 0) + request = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixMilli - elem = make([]NilStringUnixMilli, 0) + var elem []url.URL + elem = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixMilli - if err := elemElem.Decode(d, json.DecodeStringUnixMilli); err != nil { + var elemElem url.URL + v, err := json.DecodeURI(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -23806,8 +24706,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayArrayReque } } -func (s *Server) decodeTestRequestRequiredStringUnixNanoRequest(r *http.Request, span trace.Span) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Request, span trace.Span) ( + req NilURI, close func() error, rerr error, ) { @@ -23837,7 +24737,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoRequest(r *http.Request, return req, close, validate.ErrBodyRequired } - var request time.Time + var request NilURI buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23849,9 +24749,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - v, err := json.DecodeStringUnixNano(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -23864,8 +24762,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoRequest(r *http.Request, } } -func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilURI, close func() error, rerr error, ) { @@ -23895,7 +24793,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayRequest(r *http.Req return req, close, validate.ErrBodyRequired } - var request []time.Time + var request []NilURI buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23907,12 +24805,10 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixNano(d) - elem = v - if err != nil { + var elem NilURI + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -23938,8 +24834,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilURI, close func() error, rerr error, ) { @@ -23969,7 +24865,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r *htt return req, close, validate.ErrBodyRequired } - var request [][]time.Time + var request [][]NilURI buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -23981,15 +24877,13 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilURI + elem = make([]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixNano(d) - elemElem = v - if err != nil { + var elemElem NilURI + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -24037,8 +24931,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableRequest(r *http.Request, span trace.Span) ( - req NilStringUnixNano, +func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request, span trace.Span) ( + req uuid.UUID, close func() error, rerr error, ) { @@ -24068,7 +24962,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableRequest(r *http. return req, close, validate.ErrBodyRequired } - var request NilStringUnixNano + var request uuid.UUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24080,7 +24974,9 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { + v, err := json.DecodeUUID(d) + request = v + if err != nil { return err } return nil @@ -24093,8 +24989,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixNano, +func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request, span trace.Span) ( + req []uuid.UUID, close func() error, rerr error, ) { @@ -24124,7 +25020,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r * return req, close, validate.ErrBodyRequired } - var request []NilStringUnixNano + var request []uuid.UUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24136,10 +25032,12 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r * d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixNano, 0) + request = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixNano - if err := elem.Decode(d, json.DecodeStringUnixNano); err != nil { + var elem uuid.UUID + v, err := json.DecodeUUID(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -24165,8 +25063,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixNano, +func (s *Server) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uuid.UUID, close func() error, rerr error, ) { @@ -24196,7 +25094,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayArrayReques return req, close, validate.ErrBodyRequired } - var request [][]NilStringUnixNano + var request [][]uuid.UUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24208,13 +25106,15 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayArrayReques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixNano, 0) + request = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixNano - elem = make([]NilStringUnixNano, 0) + var elem []uuid.UUID + elem = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixNano - if err := elemElem.Decode(d, json.DecodeStringUnixNano); err != nil { + var elemElem uuid.UUID + v, err := json.DecodeUUID(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -24262,8 +25162,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayArrayReques } } -func (s *Server) decodeTestRequestRequiredStringUnixNullableRequest(r *http.Request, span trace.Span) ( - req NilStringUnixSeconds, +func (s *Server) decodeTestRequestRequiredStringUUIDNullableRequest(r *http.Request, span trace.Span) ( + req NilUUID, close func() error, rerr error, ) { @@ -24293,7 +25193,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableRequest(r *http.Requ return req, close, validate.ErrBodyRequired } - var request NilStringUnixSeconds + var request NilUUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24305,7 +25205,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -24318,8 +25218,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixSeconds, +func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUUID, close func() error, rerr error, ) { @@ -24349,7 +25249,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayRequest(r *http return req, close, validate.ErrBodyRequired } - var request []NilStringUnixSeconds + var request []NilUUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24361,10 +25261,10 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayRequest(r *http d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixSeconds, 0) + request = make([]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixSeconds - if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elem NilUUID + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -24390,8 +25290,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixSeconds, +func (s *Server) decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUUID, close func() error, rerr error, ) { @@ -24421,7 +25321,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r return req, close, validate.ErrBodyRequired } - var request [][]NilStringUnixSeconds + var request [][]NilUUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24433,13 +25333,13 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixSeconds, 0) + request = make([][]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixSeconds - elem = make([]NilStringUnixSeconds, 0) + var elem []NilUUID + elem = make([]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixSeconds - if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elemElem NilUUID + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -24487,7 +25387,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringUnixSecondsRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringUnixRequest(r *http.Request, span trace.Span) ( req time.Time, close func() error, rerr error, @@ -24545,7 +25445,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredStringUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringUnixArrayRequest(r *http.Request, span trace.Span) ( req []time.Time, close func() error, rerr error, @@ -24619,7 +25519,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringUnixArrayArrayRequest(r *http.Request, span trace.Span) ( req [][]time.Time, close func() error, rerr error, @@ -24718,8 +25618,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( - req NilStringUnixSeconds, +func (s *Server) decodeTestRequestRequiredStringUnixMicroRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -24749,7 +25649,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableRequest(r *ht return req, close, validate.ErrBodyRequired } - var request NilStringUnixSeconds + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24761,7 +25661,9 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + v, err := json.DecodeStringUnixMicro(d) + request = v + if err != nil { return err } return nil @@ -24774,8 +25676,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableRequest(r *ht } } -func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixSeconds, +func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -24805,7 +25707,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest( return req, close, validate.ErrBodyRequired } - var request []NilStringUnixSeconds + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24817,10 +25719,12 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest( d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixSeconds, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixSeconds - if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elem time.Time + v, err := json.DecodeStringUnixMicro(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -24846,8 +25750,163 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest( } } -func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixSeconds, +func (s *Server) decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request [][]time.Time + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []time.Time + elem = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem time.Time + v, err := json.DecodeStringUnixMicro(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableRequest(r *http.Request, span trace.Span) ( + req NilStringUnixMicro, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request NilStringUnixMicro + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixMicro, close func() error, rerr error, ) { @@ -24877,7 +25936,7 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayReq return req, close, validate.ErrBodyRequired } - var request [][]NilStringUnixSeconds + var request []NilStringUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -24889,13 +25948,85 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayReq d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixSeconds, 0) + request = make([]NilStringUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixSeconds - elem = make([]NilStringUnixSeconds, 0) + var elem NilStringUnixMicro + if err := elem.Decode(d, json.DecodeStringUnixMicro); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixMicro, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request [][]NilStringUnixMicro + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilStringUnixMicro, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilStringUnixMicro + elem = make([]NilStringUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixSeconds - if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elemElem NilStringUnixMicro + if err := elemElem.Decode(d, json.DecodeStringUnixMicro); err != nil { return err } elem = append(elem, elemElem) @@ -24943,8 +26074,8 @@ func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayReq } } -func (s *Server) decodeTestRequestStringRequest(r *http.Request, span trace.Span) ( - req OptString, +func (s *Server) decodeTestRequestRequiredStringUnixMilliRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -24963,9 +26094,6 @@ func (s *Server) decodeTestRequestStringRequest(r *http.Request, span trace.Span rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -24974,23 +26102,24 @@ func (s *Server) decodeTestRequestStringRequest(r *http.Request, span trace.Span switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request OptString + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request.Reset() - if err := request.Decode(d); err != nil { + v, err := json.DecodeStringUnixMilli(d) + request = v + if err != nil { return err } return nil @@ -25003,8 +26132,8 @@ func (s *Server) decodeTestRequestStringRequest(r *http.Request, span trace.Span } } -func (s *Server) decodeTestRequestStringArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -25023,9 +26152,6 @@ func (s *Server) decodeTestRequestStringArrayRequest(r *http.Request, span trace rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25034,26 +26160,26 @@ func (s *Server) decodeTestRequestStringArrayRequest(r *http.Request, span trace switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request []string + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) + var elem time.Time + v, err := json.DecodeStringUnixMilli(d) + elem = v if err != nil { return err } @@ -25066,14 +26192,22 @@ func (s *Server) decodeTestRequestStringArrayRequest(r *http.Request, span trace }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -25092,9 +26226,6 @@ func (s *Server) decodeTestRequestStringArrayArrayRequest(r *http.Request, span rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25103,29 +26234,29 @@ func (s *Server) decodeTestRequestStringArrayArrayRequest(r *http.Request, span switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][]string + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) + var elemElem time.Time + v, err := json.DecodeStringUnixMilli(d) + elemElem = v if err != nil { return err } @@ -25144,6 +26275,9 @@ func (s *Server) decodeTestRequestStringArrayArrayRequest(r *http.Request, span return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -25171,8 +26305,8 @@ func (s *Server) decodeTestRequestStringArrayArrayRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestStringBinaryRequest(r *http.Request, span trace.Span) ( - req OptString, +func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableRequest(r *http.Request, span trace.Span) ( + req NilStringUnixMilli, close func() error, rerr error, ) { @@ -25191,9 +26325,6 @@ func (s *Server) decodeTestRequestStringBinaryRequest(r *http.Request, span trac rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25202,23 +26333,22 @@ func (s *Server) decodeTestRequestStringBinaryRequest(r *http.Request, span trac switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request OptString + var request NilStringUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } return nil @@ -25231,8 +26361,8 @@ func (s *Server) decodeTestRequestStringBinaryRequest(r *http.Request, span trac } } -func (s *Server) decodeTestRequestStringBinaryArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixMilli, close func() error, rerr error, ) { @@ -25251,9 +26381,6 @@ func (s *Server) decodeTestRequestStringBinaryArrayRequest(r *http.Request, span rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25262,27 +26389,25 @@ func (s *Server) decodeTestRequestStringBinaryArrayRequest(r *http.Request, span switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request []string + var request []NilStringUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]NilStringUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { + var elem NilStringUnixMilli + if err := elem.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } request = append(request, elem) @@ -25294,14 +26419,22 @@ func (s *Server) decodeTestRequestStringBinaryArrayRequest(r *http.Request, span }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringBinaryArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixMilli, close func() error, rerr error, ) { @@ -25320,9 +26453,6 @@ func (s *Server) decodeTestRequestStringBinaryArrayArrayRequest(r *http.Request, rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25331,30 +26461,28 @@ func (s *Server) decodeTestRequestStringBinaryArrayArrayRequest(r *http.Request, switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][]string + var request [][]NilStringUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]NilStringUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []NilStringUnixMilli + elem = make([]NilStringUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) - if err != nil { + var elemElem NilStringUnixMilli + if err := elemElem.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } elem = append(elem, elemElem) @@ -25372,6 +26500,9 @@ func (s *Server) decodeTestRequestStringBinaryArrayArrayRequest(r *http.Request, return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -25399,8 +26530,8 @@ func (s *Server) decodeTestRequestStringBinaryArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringBinaryNullableRequest(r *http.Request, span trace.Span) ( - req OptNilString, +func (s *Server) decodeTestRequestRequiredStringUnixNanoRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -25419,9 +26550,6 @@ func (s *Server) decodeTestRequestStringBinaryNullableRequest(r *http.Request, s rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25430,23 +26558,24 @@ func (s *Server) decodeTestRequestStringBinaryNullableRequest(r *http.Request, s switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request OptNilString + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request.Reset() - if err := request.Decode(d); err != nil { + v, err := json.DecodeStringUnixNano(d) + request = v + if err != nil { return err } return nil @@ -25459,8 +26588,8 @@ func (s *Server) decodeTestRequestStringBinaryNullableRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringBinaryNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -25479,9 +26608,6 @@ func (s *Server) decodeTestRequestStringBinaryNullableArrayRequest(r *http.Reque rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25490,25 +26616,27 @@ func (s *Server) decodeTestRequestStringBinaryNullableArrayRequest(r *http.Reque switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request []NilString + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem time.Time + v, err := json.DecodeStringUnixNano(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -25520,14 +26648,22 @@ func (s *Server) decodeTestRequestStringBinaryNullableArrayRequest(r *http.Reque }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringBinaryNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -25546,9 +26682,6 @@ func (s *Server) decodeTestRequestStringBinaryNullableArrayArrayRequest(r *http. rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25557,28 +26690,30 @@ func (s *Server) decodeTestRequestStringBinaryNullableArrayArrayRequest(r *http. switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][]NilString + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem time.Time + v, err := json.DecodeStringUnixNano(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -25596,6 +26731,9 @@ func (s *Server) decodeTestRequestStringBinaryNullableArrayArrayRequest(r *http. return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -25623,8 +26761,8 @@ func (s *Server) decodeTestRequestStringBinaryNullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestStringByteRequest(r *http.Request, span trace.Span) ( - req []byte, +func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableRequest(r *http.Request, span trace.Span) ( + req NilStringUnixNano, close func() error, rerr error, ) { @@ -25643,9 +26781,6 @@ func (s *Server) decodeTestRequestStringByteRequest(r *http.Request, span trace. rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25654,24 +26789,22 @@ func (s *Server) decodeTestRequestStringByteRequest(r *http.Request, span trace. switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request []byte + var request NilStringUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Base64() - request = []byte(v) - if err != nil { + if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { return err } return nil @@ -25684,8 +26817,8 @@ func (s *Server) decodeTestRequestStringByteRequest(r *http.Request, span trace. } } -func (s *Server) decodeTestRequestStringByteArrayRequest(r *http.Request, span trace.Span) ( - req [][]byte, +func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixNano, close func() error, rerr error, ) { @@ -25704,9 +26837,6 @@ func (s *Server) decodeTestRequestStringByteArrayRequest(r *http.Request, span t rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25715,27 +26845,25 @@ func (s *Server) decodeTestRequestStringByteArrayRequest(r *http.Request, span t switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][]byte + var request []NilStringUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]byte, 0) + request = make([]NilStringUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []byte - v, err := d.Base64() - elem = []byte(v) - if err != nil { + var elem NilStringUnixNano + if err := elem.Decode(d, json.DecodeStringUnixNano); err != nil { return err } request = append(request, elem) @@ -25747,14 +26875,22 @@ func (s *Server) decodeTestRequestStringByteArrayRequest(r *http.Request, span t }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringByteArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][][]byte, +func (s *Server) decodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixNano, close func() error, rerr error, ) { @@ -25773,9 +26909,6 @@ func (s *Server) decodeTestRequestStringByteArrayArrayRequest(r *http.Request, s rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25784,30 +26917,28 @@ func (s *Server) decodeTestRequestStringByteArrayArrayRequest(r *http.Request, s switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][][]byte + var request [][]NilStringUnixNano buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][][]byte, 0) + request = make([][]NilStringUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem [][]byte - elem = make([][]byte, 0) + var elem []NilStringUnixNano + elem = make([]NilStringUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem []byte - v, err := d.Base64() - elemElem = []byte(v) - if err != nil { + var elemElem NilStringUnixNano + if err := elemElem.Decode(d, json.DecodeStringUnixNano); err != nil { return err } elem = append(elem, elemElem) @@ -25825,6 +26956,9 @@ func (s *Server) decodeTestRequestStringByteArrayArrayRequest(r *http.Request, s return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -25852,8 +26986,8 @@ func (s *Server) decodeTestRequestStringByteArrayArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringByteNullableRequest(r *http.Request, span trace.Span) ( - req OptNilByte, +func (s *Server) decodeTestRequestRequiredStringUnixNullableRequest(r *http.Request, span trace.Span) ( + req NilStringUnixSeconds, close func() error, rerr error, ) { @@ -25872,9 +27006,6 @@ func (s *Server) decodeTestRequestStringByteNullableRequest(r *http.Request, spa rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25883,23 +27014,22 @@ func (s *Server) decodeTestRequestStringByteNullableRequest(r *http.Request, spa switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request OptNilByte + var request NilStringUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } return nil @@ -25912,8 +27042,8 @@ func (s *Server) decodeTestRequestStringByteNullableRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringByteNullableArrayRequest(r *http.Request, span trace.Span) ( - req [][]byte, +func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixSeconds, close func() error, rerr error, ) { @@ -25932,9 +27062,6 @@ func (s *Server) decodeTestRequestStringByteNullableArrayRequest(r *http.Request rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -25943,27 +27070,25 @@ func (s *Server) decodeTestRequestStringByteNullableArrayRequest(r *http.Request switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][]byte + var request []NilStringUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]byte, 0) + request = make([]NilStringUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []byte - v, err := d.Base64() - elem = []byte(v) - if err != nil { + var elem NilStringUnixSeconds + if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } request = append(request, elem) @@ -25975,14 +27100,22 @@ func (s *Server) decodeTestRequestStringByteNullableArrayRequest(r *http.Request }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringByteNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][][]byte, +func (s *Server) decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixSeconds, close func() error, rerr error, ) { @@ -26001,9 +27134,6 @@ func (s *Server) decodeTestRequestStringByteNullableArrayArrayRequest(r *http.Re rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -26012,30 +27142,28 @@ func (s *Server) decodeTestRequestStringByteNullableArrayArrayRequest(r *http.Re switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][][]byte + var request [][]NilStringUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][][]byte, 0) + request = make([][]NilStringUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem [][]byte - elem = make([][]byte, 0) + var elem []NilStringUnixSeconds + elem = make([]NilStringUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem []byte - v, err := d.Base64() - elemElem = []byte(v) - if err != nil { + var elemElem NilStringUnixSeconds + if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } elem = append(elem, elemElem) @@ -26053,6 +27181,9 @@ func (s *Server) decodeTestRequestStringByteNullableArrayArrayRequest(r *http.Re return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -26080,8 +27211,8 @@ func (s *Server) decodeTestRequestStringByteNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringDateRequest(r *http.Request, span trace.Span) ( - req OptDate, +func (s *Server) decodeTestRequestRequiredStringUnixSecondsRequest(r *http.Request, span trace.Span) ( + req time.Time, close func() error, rerr error, ) { @@ -26100,9 +27231,6 @@ func (s *Server) decodeTestRequestStringDateRequest(r *http.Request, span trace. rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -26111,23 +27239,24 @@ func (s *Server) decodeTestRequestStringDateRequest(r *http.Request, span trace. switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request OptDate + var request time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request.Reset() - if err := request.Decode(d, json.DecodeDate); err != nil { + v, err := json.DecodeStringUnixSeconds(d) + request = v + if err != nil { return err } return nil @@ -26140,7 +27269,7 @@ func (s *Server) decodeTestRequestStringDateRequest(r *http.Request, span trace. } } -func (s *Server) decodeTestRequestStringDateArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( req []time.Time, close func() error, rerr error, @@ -26160,9 +27289,6 @@ func (s *Server) decodeTestRequestStringDateArrayRequest(r *http.Request, span t rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -26171,7 +27297,7 @@ func (s *Server) decodeTestRequestStringDateArrayRequest(r *http.Request, span t switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } var request []time.Time @@ -26181,7 +27307,7 @@ func (s *Server) decodeTestRequestStringDateArrayRequest(r *http.Request, span t } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) @@ -26189,7 +27315,7 @@ func (s *Server) decodeTestRequestStringDateArrayRequest(r *http.Request, span t request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem time.Time - v, err := json.DecodeDate(d) + v, err := json.DecodeStringUnixSeconds(d) elem = v if err != nil { return err @@ -26203,13 +27329,21 @@ func (s *Server) decodeTestRequestStringDateArrayRequest(r *http.Request, span t }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( req [][]time.Time, close func() error, rerr error, @@ -26229,9 +27363,6 @@ func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, s rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -26240,7 +27371,7 @@ func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, s switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } var request [][]time.Time @@ -26250,7 +27381,7 @@ func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, s } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) @@ -26261,7 +27392,7 @@ func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, s elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elemElem time.Time - v, err := json.DecodeDate(d) + v, err := json.DecodeStringUnixSeconds(d) elemElem = v if err != nil { return err @@ -26281,6 +27412,9 @@ func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, s return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -26308,8 +27442,8 @@ func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringDateNullableRequest(r *http.Request, span trace.Span) ( - req OptNilDate, +func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( + req NilStringUnixSeconds, close func() error, rerr error, ) { @@ -26328,9 +27462,6 @@ func (s *Server) decodeTestRequestStringDateNullableRequest(r *http.Request, spa rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -26339,23 +27470,22 @@ func (s *Server) decodeTestRequestStringDateNullableRequest(r *http.Request, spa switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request OptNilDate + var request NilStringUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request.Reset() - if err := request.Decode(d, json.DecodeDate); err != nil { + if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } return nil @@ -26368,8 +27498,8 @@ func (s *Server) decodeTestRequestStringDateNullableRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringDateNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilDate, +func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixSeconds, close func() error, rerr error, ) { @@ -26388,9 +27518,6 @@ func (s *Server) decodeTestRequestStringDateNullableArrayRequest(r *http.Request rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -26399,25 +27526,25 @@ func (s *Server) decodeTestRequestStringDateNullableArrayRequest(r *http.Request switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request []NilDate + var request []NilStringUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilDate, 0) + request = make([]NilStringUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilDate - if err := elem.Decode(d, json.DecodeDate); err != nil { + var elem NilStringUnixSeconds + if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } request = append(request, elem) @@ -26429,14 +27556,22 @@ func (s *Server) decodeTestRequestStringDateNullableArrayRequest(r *http.Request }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringDateNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilDate, +func (s *Server) decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixSeconds, close func() error, rerr error, ) { @@ -26455,9 +27590,6 @@ func (s *Server) decodeTestRequestStringDateNullableArrayArrayRequest(r *http.Re rerr = multierr.Append(rerr, close()) } }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -26466,28 +27598,28 @@ func (s *Server) decodeTestRequestStringDateNullableArrayArrayRequest(r *http.Re switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } - var request [][]NilDate + var request [][]NilStringUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, nil + return req, close, validate.ErrBodyRequired } d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilDate, 0) + request = make([][]NilStringUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilDate - elem = make([]NilDate, 0) + var elem []NilStringUnixSeconds + elem = make([]NilStringUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilDate - if err := elemElem.Decode(d, json.DecodeDate); err != nil { + var elemElem NilStringUnixSeconds + if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } elem = append(elem, elemElem) @@ -26505,6 +27637,9 @@ func (s *Server) decodeTestRequestStringDateNullableArrayArrayRequest(r *http.Re return req, close, errors.Wrap(err, "decode \"application/json\"") } if err := func() error { + if request == nil { + return errors.New("nil is invalid value") + } var failures []validate.FieldError for i, elem := range request { if err := func() error { @@ -26532,8 +27667,8 @@ func (s *Server) decodeTestRequestStringDateNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringDateTimeRequest(r *http.Request, span trace.Span) ( - req OptDateTime, +func (s *Server) decodeTestRequestStringRequest(r *http.Request, span trace.Span) ( + req OptString, close func() error, rerr error, ) { @@ -26566,7 +27701,7 @@ func (s *Server) decodeTestRequestStringDateTimeRequest(r *http.Request, span tr return req, close, nil } - var request OptDateTime + var request OptString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -26579,7 +27714,7 @@ func (s *Server) decodeTestRequestStringDateTimeRequest(r *http.Request, span tr d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeDateTime); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -26592,8 +27727,8 @@ func (s *Server) decodeTestRequestStringDateTimeRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestStringDateTimeArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestStringArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -26626,7 +27761,7 @@ func (s *Server) decodeTestRequestStringDateTimeArrayRequest(r *http.Request, sp return req, close, nil } - var request []time.Time + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -26638,11 +27773,11 @@ func (s *Server) decodeTestRequestStringDateTimeArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeDateTime(d) - elem = v + var elem string + v, err := d.Str() + elem = string(v) if err != nil { return err } @@ -26661,8 +27796,8 @@ func (s *Server) decodeTestRequestStringDateTimeArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestStringDateTimeArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -26695,7 +27830,7 @@ func (s *Server) decodeTestRequestStringDateTimeArrayArrayRequest(r *http.Reques return req, close, nil } - var request [][]time.Time + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -26707,14 +27842,14 @@ func (s *Server) decodeTestRequestStringDateTimeArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeDateTime(d) - elemElem = v + var elemElem string + v, err := d.Str() + elemElem = string(v) if err != nil { return err } @@ -26760,8 +27895,8 @@ func (s *Server) decodeTestRequestStringDateTimeArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringDateTimeNullableRequest(r *http.Request, span trace.Span) ( - req OptNilDateTime, +func (s *Server) decodeTestRequestStringBinaryRequest(r *http.Request, span trace.Span) ( + req OptString, close func() error, rerr error, ) { @@ -26794,7 +27929,7 @@ func (s *Server) decodeTestRequestStringDateTimeNullableRequest(r *http.Request, return req, close, nil } - var request OptNilDateTime + var request OptString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -26807,7 +27942,7 @@ func (s *Server) decodeTestRequestStringDateTimeNullableRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeDateTime); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -26820,8 +27955,8 @@ func (s *Server) decodeTestRequestStringDateTimeNullableRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringDateTimeNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilDateTime, +func (s *Server) decodeTestRequestStringBinaryArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -26854,7 +27989,7 @@ func (s *Server) decodeTestRequestStringDateTimeNullableArrayRequest(r *http.Req return req, close, nil } - var request []NilDateTime + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -26866,10 +28001,12 @@ func (s *Server) decodeTestRequestStringDateTimeNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilDateTime, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilDateTime - if err := elem.Decode(d, json.DecodeDateTime); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } request = append(request, elem) @@ -26887,8 +28024,8 @@ func (s *Server) decodeTestRequestStringDateTimeNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringDateTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilDateTime, +func (s *Server) decodeTestRequestStringBinaryArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -26921,7 +28058,7 @@ func (s *Server) decodeTestRequestStringDateTimeNullableArrayArrayRequest(r *htt return req, close, nil } - var request [][]NilDateTime + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -26933,13 +28070,15 @@ func (s *Server) decodeTestRequestStringDateTimeNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilDateTime, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilDateTime - elem = make([]NilDateTime, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilDateTime - if err := elemElem.Decode(d, json.DecodeDateTime); err != nil { + var elemElem string + v, err := d.Str() + elemElem = string(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -26984,8 +28123,8 @@ func (s *Server) decodeTestRequestStringDateTimeNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestStringDurationRequest(r *http.Request, span trace.Span) ( - req OptDuration, +func (s *Server) decodeTestRequestStringBinaryNullableRequest(r *http.Request, span trace.Span) ( + req OptNilString, close func() error, rerr error, ) { @@ -27018,7 +28157,7 @@ func (s *Server) decodeTestRequestStringDurationRequest(r *http.Request, span tr return req, close, nil } - var request OptDuration + var request OptNilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27044,8 +28183,8 @@ func (s *Server) decodeTestRequestStringDurationRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestStringDurationArrayRequest(r *http.Request, span trace.Span) ( - req []time.Duration, +func (s *Server) decodeTestRequestStringBinaryNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -27078,7 +28217,7 @@ func (s *Server) decodeTestRequestStringDurationArrayRequest(r *http.Request, sp return req, close, nil } - var request []time.Duration + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27090,12 +28229,10 @@ func (s *Server) decodeTestRequestStringDurationArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Duration, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Duration - v, err := json.DecodeDuration(d) - elem = v - if err != nil { + var elem NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -27113,8 +28250,8 @@ func (s *Server) decodeTestRequestStringDurationArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestStringDurationArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Duration, +func (s *Server) decodeTestRequestStringBinaryNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -27147,7 +28284,7 @@ func (s *Server) decodeTestRequestStringDurationArrayArrayRequest(r *http.Reques return req, close, nil } - var request [][]time.Duration + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27159,15 +28296,13 @@ func (s *Server) decodeTestRequestStringDurationArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Duration, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Duration - elem = make([]time.Duration, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Duration - v, err := json.DecodeDuration(d) - elemElem = v - if err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -27212,8 +28347,8 @@ func (s *Server) decodeTestRequestStringDurationArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringDurationNullableRequest(r *http.Request, span trace.Span) ( - req OptNilDuration, +func (s *Server) decodeTestRequestStringByteRequest(r *http.Request, span trace.Span) ( + req []byte, close func() error, rerr error, ) { @@ -27246,7 +28381,7 @@ func (s *Server) decodeTestRequestStringDurationNullableRequest(r *http.Request, return req, close, nil } - var request OptNilDuration + var request []byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27258,8 +28393,9 @@ func (s *Server) decodeTestRequestStringDurationNullableRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request.Reset() - if err := request.Decode(d); err != nil { + v, err := d.Base64() + request = []byte(v) + if err != nil { return err } return nil @@ -27272,8 +28408,8 @@ func (s *Server) decodeTestRequestStringDurationNullableRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringDurationNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilDuration, +func (s *Server) decodeTestRequestStringByteArrayRequest(r *http.Request, span trace.Span) ( + req [][]byte, close func() error, rerr error, ) { @@ -27306,7 +28442,7 @@ func (s *Server) decodeTestRequestStringDurationNullableArrayRequest(r *http.Req return req, close, nil } - var request []NilDuration + var request [][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27318,10 +28454,12 @@ func (s *Server) decodeTestRequestStringDurationNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilDuration, 0) + request = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilDuration - if err := elem.Decode(d); err != nil { + var elem []byte + v, err := d.Base64() + elem = []byte(v) + if err != nil { return err } request = append(request, elem) @@ -27339,8 +28477,8 @@ func (s *Server) decodeTestRequestStringDurationNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringDurationNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilDuration, +func (s *Server) decodeTestRequestStringByteArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][][]byte, close func() error, rerr error, ) { @@ -27373,7 +28511,7 @@ func (s *Server) decodeTestRequestStringDurationNullableArrayArrayRequest(r *htt return req, close, nil } - var request [][]NilDuration + var request [][][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27385,13 +28523,15 @@ func (s *Server) decodeTestRequestStringDurationNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilDuration, 0) + request = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilDuration - elem = make([]NilDuration, 0) + var elem [][]byte + elem = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilDuration - if err := elemElem.Decode(d); err != nil { + var elemElem []byte + v, err := d.Base64() + elemElem = []byte(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -27436,8 +28576,8 @@ func (s *Server) decodeTestRequestStringDurationNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestStringEmailRequest(r *http.Request, span trace.Span) ( - req OptString, +func (s *Server) decodeTestRequestStringByteNullableRequest(r *http.Request, span trace.Span) ( + req OptNilByte, close func() error, rerr error, ) { @@ -27470,7 +28610,7 @@ func (s *Server) decodeTestRequestStringEmailRequest(r *http.Request, span trace return req, close, nil } - var request OptString + var request OptNilByte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27490,37 +28630,14 @@ func (s *Server) decodeTestRequestStringEmailRequest(r *http.Request, span trace }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringEmailArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestStringByteNullableArrayRequest(r *http.Request, span trace.Span) ( + req [][]byte, close func() error, rerr error, ) { @@ -27553,7 +28670,7 @@ func (s *Server) decodeTestRequestStringEmailArrayRequest(r *http.Request, span return req, close, nil } - var request []string + var request [][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27565,11 +28682,11 @@ func (s *Server) decodeTestRequestStringEmailArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) + var elem []byte + v, err := d.Base64() + elem = []byte(v) if err != nil { return err } @@ -27582,44 +28699,14 @@ func (s *Server) decodeTestRequestStringEmailArrayRequest(r *http.Request, span }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringEmailArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestStringByteNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][][]byte, close func() error, rerr error, ) { @@ -27652,7 +28739,7 @@ func (s *Server) decodeTestRequestStringEmailArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]string + var request [][][]byte buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27664,14 +28751,14 @@ func (s *Server) decodeTestRequestStringEmailArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem [][]byte + elem = make([][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) + var elemElem []byte + v, err := d.Base64() + elemElem = []byte(v) if err != nil { return err } @@ -27696,31 +28783,6 @@ func (s *Server) decodeTestRequestStringEmailArrayArrayRequest(r *http.Request, if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -27742,8 +28804,8 @@ func (s *Server) decodeTestRequestStringEmailArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringEmailNullableRequest(r *http.Request, span trace.Span) ( - req OptNilString, +func (s *Server) decodeTestRequestStringDateRequest(r *http.Request, span trace.Span) ( + req OptDate, close func() error, rerr error, ) { @@ -27776,7 +28838,7 @@ func (s *Server) decodeTestRequestStringEmailNullableRequest(r *http.Request, sp return req, close, nil } - var request OptNilString + var request OptDate buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27789,44 +28851,21 @@ func (s *Server) decodeTestRequestStringEmailNullableRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeDate); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringEmailNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestStringDateArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -27859,7 +28898,7 @@ func (s *Server) decodeTestRequestStringEmailNullableArrayRequest(r *http.Reques return req, close, nil } - var request []NilString + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27871,10 +28910,12 @@ func (s *Server) decodeTestRequestStringEmailNullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem time.Time + v, err := json.DecodeDate(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -27886,44 +28927,14 @@ func (s *Server) decodeTestRequestStringEmailNullableArrayRequest(r *http.Reques }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringEmailNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestStringDateArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -27956,7 +28967,7 @@ func (s *Server) decodeTestRequestStringEmailNullableArrayArrayRequest(r *http.R return req, close, nil } - var request [][]NilString + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -27968,13 +28979,15 @@ func (s *Server) decodeTestRequestStringEmailNullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem time.Time + v, err := json.DecodeDate(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -27998,31 +29011,6 @@ func (s *Server) decodeTestRequestStringEmailNullableArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: true, - Hostname: false, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -28044,8 +29032,8 @@ func (s *Server) decodeTestRequestStringEmailNullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestStringHostnameRequest(r *http.Request, span trace.Span) ( - req OptString, +func (s *Server) decodeTestRequestStringDateNullableRequest(r *http.Request, span trace.Span) ( + req OptNilDate, close func() error, rerr error, ) { @@ -28078,7 +29066,7 @@ func (s *Server) decodeTestRequestStringHostnameRequest(r *http.Request, span tr return req, close, nil } - var request OptString + var request OptNilDate buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28091,44 +29079,21 @@ func (s *Server) decodeTestRequestStringHostnameRequest(r *http.Request, span tr d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeDate); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringHostnameArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestStringDateNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilDate, close func() error, rerr error, ) { @@ -28161,7 +29126,7 @@ func (s *Server) decodeTestRequestStringHostnameArrayRequest(r *http.Request, sp return req, close, nil } - var request []string + var request []NilDate buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28173,12 +29138,10 @@ func (s *Server) decodeTestRequestStringHostnameArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]NilDate, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { + var elem NilDate + if err := elem.Decode(d, json.DecodeDate); err != nil { return err } request = append(request, elem) @@ -28190,44 +29153,14 @@ func (s *Server) decodeTestRequestStringHostnameArrayRequest(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringHostnameArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestStringDateNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilDate, close func() error, rerr error, ) { @@ -28260,7 +29193,7 @@ func (s *Server) decodeTestRequestStringHostnameArrayArrayRequest(r *http.Reques return req, close, nil } - var request [][]string + var request [][]NilDate buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28272,15 +29205,13 @@ func (s *Server) decodeTestRequestStringHostnameArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]NilDate, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []NilDate + elem = make([]NilDate, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) - if err != nil { + var elemElem NilDate + if err := elemElem.Decode(d, json.DecodeDate); err != nil { return err } elem = append(elem, elemElem) @@ -28304,31 +29235,6 @@ func (s *Server) decodeTestRequestStringHostnameArrayArrayRequest(r *http.Reques if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -28350,8 +29256,8 @@ func (s *Server) decodeTestRequestStringHostnameArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringHostnameNullableRequest(r *http.Request, span trace.Span) ( - req OptNilString, +func (s *Server) decodeTestRequestStringDateTimeRequest(r *http.Request, span trace.Span) ( + req OptDateTime, close func() error, rerr error, ) { @@ -28384,7 +29290,7 @@ func (s *Server) decodeTestRequestStringHostnameNullableRequest(r *http.Request, return req, close, nil } - var request OptNilString + var request OptDateTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28397,44 +29303,21 @@ func (s *Server) decodeTestRequestStringHostnameNullableRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeDateTime); err != nil { return err } return nil }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - if request.Set { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(request.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringHostnameNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestStringDateTimeArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -28467,7 +29350,7 @@ func (s *Server) decodeTestRequestStringHostnameNullableArrayRequest(r *http.Req return req, close, nil } - var request []NilString + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28479,10 +29362,12 @@ func (s *Server) decodeTestRequestStringHostnameNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem time.Time + v, err := json.DecodeDateTime(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -28494,44 +29379,14 @@ func (s *Server) decodeTestRequestStringHostnameNullableArrayRequest(r *http.Req }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } - if err := func() error { - var failures []validate.FieldError - for i, elem := range request { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringHostnameNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestStringDateTimeArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -28564,7 +29419,7 @@ func (s *Server) decodeTestRequestStringHostnameNullableArrayArrayRequest(r *htt return req, close, nil } - var request [][]NilString + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28576,13 +29431,15 @@ func (s *Server) decodeTestRequestStringHostnameNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem time.Time + v, err := json.DecodeDateTime(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -28606,31 +29463,6 @@ func (s *Server) decodeTestRequestStringHostnameNullableArrayArrayRequest(r *htt if elem == nil { return errors.New("nil is invalid value") } - var failures []validate.FieldError - for i, elem := range elem { - if err := func() error { - if err := (validate.String{ - MinLength: 0, - MinLengthSet: false, - MaxLength: 0, - MaxLengthSet: false, - Email: false, - Hostname: true, - Regex: nil, - }).Validate(string(elem.Value)); err != nil { - return errors.Wrap(err, "string") - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -28652,8 +29484,8 @@ func (s *Server) decodeTestRequestStringHostnameNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestStringIPRequest(r *http.Request, span trace.Span) ( - req OptIP, +func (s *Server) decodeTestRequestStringDateTimeNullableRequest(r *http.Request, span trace.Span) ( + req OptNilDateTime, close func() error, rerr error, ) { @@ -28686,7 +29518,7 @@ func (s *Server) decodeTestRequestStringIPRequest(r *http.Request, span trace.Sp return req, close, nil } - var request OptIP + var request OptNilDateTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28699,7 +29531,7 @@ func (s *Server) decodeTestRequestStringIPRequest(r *http.Request, span trace.Sp d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeDateTime); err != nil { return err } return nil @@ -28712,8 +29544,8 @@ func (s *Server) decodeTestRequestStringIPRequest(r *http.Request, span trace.Sp } } -func (s *Server) decodeTestRequestStringIPArrayRequest(r *http.Request, span trace.Span) ( - req []netip.Addr, +func (s *Server) decodeTestRequestStringDateTimeNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilDateTime, close func() error, rerr error, ) { @@ -28746,7 +29578,7 @@ func (s *Server) decodeTestRequestStringIPArrayRequest(r *http.Request, span tra return req, close, nil } - var request []netip.Addr + var request []NilDateTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28758,12 +29590,10 @@ func (s *Server) decodeTestRequestStringIPArrayRequest(r *http.Request, span tra d := jx.DecodeBytes(buf) if err := func() error { - request = make([]netip.Addr, 0) + request = make([]NilDateTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem netip.Addr - v, err := json.DecodeIP(d) - elem = v - if err != nil { + var elem NilDateTime + if err := elem.Decode(d, json.DecodeDateTime); err != nil { return err } request = append(request, elem) @@ -28781,8 +29611,8 @@ func (s *Server) decodeTestRequestStringIPArrayRequest(r *http.Request, span tra } } -func (s *Server) decodeTestRequestStringIPArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]netip.Addr, +func (s *Server) decodeTestRequestStringDateTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilDateTime, close func() error, rerr error, ) { @@ -28815,7 +29645,7 @@ func (s *Server) decodeTestRequestStringIPArrayArrayRequest(r *http.Request, spa return req, close, nil } - var request [][]netip.Addr + var request [][]NilDateTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28827,15 +29657,13 @@ func (s *Server) decodeTestRequestStringIPArrayArrayRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]netip.Addr, 0) + request = make([][]NilDateTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []netip.Addr - elem = make([]netip.Addr, 0) + var elem []NilDateTime + elem = make([]NilDateTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem netip.Addr - v, err := json.DecodeIP(d) - elemElem = v - if err != nil { + var elemElem NilDateTime + if err := elemElem.Decode(d, json.DecodeDateTime); err != nil { return err } elem = append(elem, elemElem) @@ -28880,8 +29708,8 @@ func (s *Server) decodeTestRequestStringIPArrayArrayRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringIPNullableRequest(r *http.Request, span trace.Span) ( - req OptNilIP, +func (s *Server) decodeTestRequestStringDurationRequest(r *http.Request, span trace.Span) ( + req OptDuration, close func() error, rerr error, ) { @@ -28914,7 +29742,7 @@ func (s *Server) decodeTestRequestStringIPNullableRequest(r *http.Request, span return req, close, nil } - var request OptNilIP + var request OptDuration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28940,8 +29768,8 @@ func (s *Server) decodeTestRequestStringIPNullableRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestStringIPNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilIP, +func (s *Server) decodeTestRequestStringDurationArrayRequest(r *http.Request, span trace.Span) ( + req []time.Duration, close func() error, rerr error, ) { @@ -28974,7 +29802,7 @@ func (s *Server) decodeTestRequestStringIPNullableArrayRequest(r *http.Request, return req, close, nil } - var request []NilIP + var request []time.Duration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -28986,10 +29814,12 @@ func (s *Server) decodeTestRequestStringIPNullableArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilIP, 0) + request = make([]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIP - if err := elem.Decode(d); err != nil { + var elem time.Duration + v, err := json.DecodeDuration(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -29007,8 +29837,8 @@ func (s *Server) decodeTestRequestStringIPNullableArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringIPNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilIP, +func (s *Server) decodeTestRequestStringDurationArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Duration, close func() error, rerr error, ) { @@ -29041,7 +29871,7 @@ func (s *Server) decodeTestRequestStringIPNullableArrayArrayRequest(r *http.Requ return req, close, nil } - var request [][]NilIP + var request [][]time.Duration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29053,13 +29883,15 @@ func (s *Server) decodeTestRequestStringIPNullableArrayArrayRequest(r *http.Requ d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilIP, 0) + request = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIP - elem = make([]NilIP, 0) + var elem []time.Duration + elem = make([]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIP - if err := elemElem.Decode(d); err != nil { + var elemElem time.Duration + v, err := json.DecodeDuration(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -29104,8 +29936,8 @@ func (s *Server) decodeTestRequestStringIPNullableArrayArrayRequest(r *http.Requ } } -func (s *Server) decodeTestRequestStringInt32Request(r *http.Request, span trace.Span) ( - req OptStringInt32, +func (s *Server) decodeTestRequestStringDurationNullableRequest(r *http.Request, span trace.Span) ( + req OptNilDuration, close func() error, rerr error, ) { @@ -29138,7 +29970,7 @@ func (s *Server) decodeTestRequestStringInt32Request(r *http.Request, span trace return req, close, nil } - var request OptStringInt32 + var request OptNilDuration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29164,8 +29996,8 @@ func (s *Server) decodeTestRequestStringInt32Request(r *http.Request, span trace } } -func (s *Server) decodeTestRequestStringInt32ArrayRequest(r *http.Request, span trace.Span) ( - req []int32, +func (s *Server) decodeTestRequestStringDurationNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilDuration, close func() error, rerr error, ) { @@ -29198,7 +30030,7 @@ func (s *Server) decodeTestRequestStringInt32ArrayRequest(r *http.Request, span return req, close, nil } - var request []int32 + var request []NilDuration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29210,12 +30042,10 @@ func (s *Server) decodeTestRequestStringInt32ArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int32, 0) + request = make([]NilDuration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int32 - v, err := json.DecodeStringInt32(d) - elem = v - if err != nil { + var elem NilDuration + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -29233,8 +30063,8 @@ func (s *Server) decodeTestRequestStringInt32ArrayRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestStringInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int32, +func (s *Server) decodeTestRequestStringDurationNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilDuration, close func() error, rerr error, ) { @@ -29267,7 +30097,7 @@ func (s *Server) decodeTestRequestStringInt32ArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]int32 + var request [][]NilDuration buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29279,15 +30109,13 @@ func (s *Server) decodeTestRequestStringInt32ArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int32, 0) + request = make([][]NilDuration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int32 - elem = make([]int32, 0) + var elem []NilDuration + elem = make([]NilDuration, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int32 - v, err := json.DecodeStringInt32(d) - elemElem = v - if err != nil { + var elemElem NilDuration + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -29332,8 +30160,8 @@ func (s *Server) decodeTestRequestStringInt32ArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringInt32NullableRequest(r *http.Request, span trace.Span) ( - req OptNilStringInt32, +func (s *Server) decodeTestRequestStringEmailRequest(r *http.Request, span trace.Span) ( + req OptString, close func() error, rerr error, ) { @@ -29366,7 +30194,7 @@ func (s *Server) decodeTestRequestStringInt32NullableRequest(r *http.Request, sp return req, close, nil } - var request OptNilStringInt32 + var request OptString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29386,14 +30214,37 @@ func (s *Server) decodeTestRequestStringInt32NullableRequest(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringInt32NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringInt32, +func (s *Server) decodeTestRequestStringEmailArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -29426,7 +30277,7 @@ func (s *Server) decodeTestRequestStringInt32NullableArrayRequest(r *http.Reques return req, close, nil } - var request []NilStringInt32 + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29438,10 +30289,12 @@ func (s *Server) decodeTestRequestStringInt32NullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringInt32, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt32 - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } request = append(request, elem) @@ -29453,14 +30306,44 @@ func (s *Server) decodeTestRequestStringInt32NullableArrayRequest(r *http.Reques }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringInt32, +func (s *Server) decodeTestRequestStringEmailArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -29493,7 +30376,7 @@ func (s *Server) decodeTestRequestStringInt32NullableArrayArrayRequest(r *http.R return req, close, nil } - var request [][]NilStringInt32 + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29505,13 +30388,15 @@ func (s *Server) decodeTestRequestStringInt32NullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringInt32, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt32 - elem = make([]NilStringInt32, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt32 - if err := elemElem.Decode(d); err != nil { + var elemElem string + v, err := d.Str() + elemElem = string(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -29535,6 +30420,31 @@ func (s *Server) decodeTestRequestStringInt32NullableArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -29556,8 +30466,8 @@ func (s *Server) decodeTestRequestStringInt32NullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestStringInt64Request(r *http.Request, span trace.Span) ( - req OptStringInt64, +func (s *Server) decodeTestRequestStringEmailNullableRequest(r *http.Request, span trace.Span) ( + req OptNilString, close func() error, rerr error, ) { @@ -29590,7 +30500,7 @@ func (s *Server) decodeTestRequestStringInt64Request(r *http.Request, span trace return req, close, nil } - var request OptStringInt64 + var request OptNilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29610,14 +30520,37 @@ func (s *Server) decodeTestRequestStringInt64Request(r *http.Request, span trace }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringInt64ArrayRequest(r *http.Request, span trace.Span) ( - req []int64, +func (s *Server) decodeTestRequestStringEmailNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -29650,7 +30583,7 @@ func (s *Server) decodeTestRequestStringInt64ArrayRequest(r *http.Request, span return req, close, nil } - var request []int64 + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29662,12 +30595,10 @@ func (s *Server) decodeTestRequestStringInt64ArrayRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { - request = make([]int64, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int64 - v, err := json.DecodeStringInt64(d) - elem = v - if err != nil { + var elem NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -29679,14 +30610,44 @@ func (s *Server) decodeTestRequestStringInt64ArrayRequest(r *http.Request, span }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]int64, +func (s *Server) decodeTestRequestStringEmailNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -29719,7 +30680,7 @@ func (s *Server) decodeTestRequestStringInt64ArrayArrayRequest(r *http.Request, return req, close, nil } - var request [][]int64 + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29731,15 +30692,13 @@ func (s *Server) decodeTestRequestStringInt64ArrayArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]int64, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int64 - elem = make([]int64, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int64 - v, err := json.DecodeStringInt64(d) - elemElem = v - if err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -29763,6 +30722,31 @@ func (s *Server) decodeTestRequestStringInt64ArrayArrayRequest(r *http.Request, if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: true, + Hostname: false, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -29784,8 +30768,8 @@ func (s *Server) decodeTestRequestStringInt64ArrayArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringInt64NullableRequest(r *http.Request, span trace.Span) ( - req OptNilStringInt64, +func (s *Server) decodeTestRequestStringHostnameRequest(r *http.Request, span trace.Span) ( + req OptString, close func() error, rerr error, ) { @@ -29818,7 +30802,7 @@ func (s *Server) decodeTestRequestStringInt64NullableRequest(r *http.Request, sp return req, close, nil } - var request OptNilStringInt64 + var request OptString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29838,14 +30822,37 @@ func (s *Server) decodeTestRequestStringInt64NullableRequest(r *http.Request, sp }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringInt64NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringInt64, +func (s *Server) decodeTestRequestStringHostnameArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -29878,7 +30885,7 @@ func (s *Server) decodeTestRequestStringInt64NullableArrayRequest(r *http.Reques return req, close, nil } - var request []NilStringInt64 + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29890,10 +30897,12 @@ func (s *Server) decodeTestRequestStringInt64NullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringInt64, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt64 - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } request = append(request, elem) @@ -29905,14 +30914,44 @@ func (s *Server) decodeTestRequestStringInt64NullableArrayRequest(r *http.Reques }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringInt64, +func (s *Server) decodeTestRequestStringHostnameArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -29945,7 +30984,7 @@ func (s *Server) decodeTestRequestStringInt64NullableArrayArrayRequest(r *http.R return req, close, nil } - var request [][]NilStringInt64 + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -29957,13 +30996,15 @@ func (s *Server) decodeTestRequestStringInt64NullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringInt64, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt64 - elem = make([]NilStringInt64, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt64 - if err := elemElem.Decode(d); err != nil { + var elemElem string + v, err := d.Str() + elemElem = string(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -29987,6 +31028,31 @@ func (s *Server) decodeTestRequestStringInt64NullableArrayArrayRequest(r *http.R if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -30008,8 +31074,8 @@ func (s *Server) decodeTestRequestStringInt64NullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestStringIpv4Request(r *http.Request, span trace.Span) ( - req OptIPv4, +func (s *Server) decodeTestRequestStringHostnameNullableRequest(r *http.Request, span trace.Span) ( + req OptNilString, close func() error, rerr error, ) { @@ -30042,7 +31108,7 @@ func (s *Server) decodeTestRequestStringIpv4Request(r *http.Request, span trace. return req, close, nil } - var request OptIPv4 + var request OptNilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30062,14 +31128,37 @@ func (s *Server) decodeTestRequestStringIpv4Request(r *http.Request, span trace. }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + if request.Set { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(request.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringIpv4ArrayRequest(r *http.Request, span trace.Span) ( - req []netip.Addr, +func (s *Server) decodeTestRequestStringHostnameNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -30102,7 +31191,7 @@ func (s *Server) decodeTestRequestStringIpv4ArrayRequest(r *http.Request, span t return req, close, nil } - var request []netip.Addr + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30114,12 +31203,10 @@ func (s *Server) decodeTestRequestStringIpv4ArrayRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { - request = make([]netip.Addr, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem netip.Addr - v, err := json.DecodeIP(d) - elem = v - if err != nil { + var elem NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -30131,14 +31218,44 @@ func (s *Server) decodeTestRequestStringIpv4ArrayRequest(r *http.Request, span t }(); err != nil { return req, close, errors.Wrap(err, "decode \"application/json\"") } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } return request, close, nil default: return req, close, validate.InvalidContentType(ct) } } -func (s *Server) decodeTestRequestStringIpv4ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]netip.Addr, +func (s *Server) decodeTestRequestStringHostnameNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -30171,7 +31288,7 @@ func (s *Server) decodeTestRequestStringIpv4ArrayArrayRequest(r *http.Request, s return req, close, nil } - var request [][]netip.Addr + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30183,15 +31300,13 @@ func (s *Server) decodeTestRequestStringIpv4ArrayArrayRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]netip.Addr, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []netip.Addr - elem = make([]netip.Addr, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem netip.Addr - v, err := json.DecodeIP(d) - elemElem = v - if err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -30215,6 +31330,31 @@ func (s *Server) decodeTestRequestStringIpv4ArrayArrayRequest(r *http.Request, s if elem == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.String{ + MinLength: 0, + MinLengthSet: false, + MaxLength: 0, + MaxLengthSet: false, + Email: false, + Hostname: true, + Regex: nil, + }).Validate(string(elem.Value)); err != nil { + return errors.Wrap(err, "string") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } return nil }(); err != nil { failures = append(failures, validate.FieldError{ @@ -30236,8 +31376,8 @@ func (s *Server) decodeTestRequestStringIpv4ArrayArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringIpv4NullableRequest(r *http.Request, span trace.Span) ( - req OptNilIPv4, +func (s *Server) decodeTestRequestStringIPRequest(r *http.Request, span trace.Span) ( + req OptIP, close func() error, rerr error, ) { @@ -30270,7 +31410,7 @@ func (s *Server) decodeTestRequestStringIpv4NullableRequest(r *http.Request, spa return req, close, nil } - var request OptNilIPv4 + var request OptIP buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30296,8 +31436,8 @@ func (s *Server) decodeTestRequestStringIpv4NullableRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringIpv4NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilIPv4, +func (s *Server) decodeTestRequestStringIPArrayRequest(r *http.Request, span trace.Span) ( + req []netip.Addr, close func() error, rerr error, ) { @@ -30330,7 +31470,7 @@ func (s *Server) decodeTestRequestStringIpv4NullableArrayRequest(r *http.Request return req, close, nil } - var request []NilIPv4 + var request []netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30342,10 +31482,12 @@ func (s *Server) decodeTestRequestStringIpv4NullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilIPv4, 0) + request = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIPv4 - if err := elem.Decode(d); err != nil { + var elem netip.Addr + v, err := json.DecodeIP(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -30363,8 +31505,8 @@ func (s *Server) decodeTestRequestStringIpv4NullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringIpv4NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilIPv4, +func (s *Server) decodeTestRequestStringIPArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]netip.Addr, close func() error, rerr error, ) { @@ -30397,7 +31539,7 @@ func (s *Server) decodeTestRequestStringIpv4NullableArrayArrayRequest(r *http.Re return req, close, nil } - var request [][]NilIPv4 + var request [][]netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30409,13 +31551,15 @@ func (s *Server) decodeTestRequestStringIpv4NullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilIPv4, 0) + request = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIPv4 - elem = make([]NilIPv4, 0) + var elem []netip.Addr + elem = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIPv4 - if err := elemElem.Decode(d); err != nil { + var elemElem netip.Addr + v, err := json.DecodeIP(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -30460,8 +31604,8 @@ func (s *Server) decodeTestRequestStringIpv4NullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringIpv6Request(r *http.Request, span trace.Span) ( - req OptIPv6, +func (s *Server) decodeTestRequestStringIPNullableRequest(r *http.Request, span trace.Span) ( + req OptNilIP, close func() error, rerr error, ) { @@ -30494,7 +31638,7 @@ func (s *Server) decodeTestRequestStringIpv6Request(r *http.Request, span trace. return req, close, nil } - var request OptIPv6 + var request OptNilIP buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30520,8 +31664,8 @@ func (s *Server) decodeTestRequestStringIpv6Request(r *http.Request, span trace. } } -func (s *Server) decodeTestRequestStringIpv6ArrayRequest(r *http.Request, span trace.Span) ( - req []netip.Addr, +func (s *Server) decodeTestRequestStringIPNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilIP, close func() error, rerr error, ) { @@ -30554,7 +31698,7 @@ func (s *Server) decodeTestRequestStringIpv6ArrayRequest(r *http.Request, span t return req, close, nil } - var request []netip.Addr + var request []NilIP buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30566,12 +31710,10 @@ func (s *Server) decodeTestRequestStringIpv6ArrayRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { - request = make([]netip.Addr, 0) + request = make([]NilIP, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem netip.Addr - v, err := json.DecodeIP(d) - elem = v - if err != nil { + var elem NilIP + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -30589,8 +31731,8 @@ func (s *Server) decodeTestRequestStringIpv6ArrayRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestStringIpv6ArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]netip.Addr, +func (s *Server) decodeTestRequestStringIPNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilIP, close func() error, rerr error, ) { @@ -30623,7 +31765,7 @@ func (s *Server) decodeTestRequestStringIpv6ArrayArrayRequest(r *http.Request, s return req, close, nil } - var request [][]netip.Addr + var request [][]NilIP buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30635,15 +31777,13 @@ func (s *Server) decodeTestRequestStringIpv6ArrayArrayRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]netip.Addr, 0) + request = make([][]NilIP, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []netip.Addr - elem = make([]netip.Addr, 0) + var elem []NilIP + elem = make([]NilIP, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem netip.Addr - v, err := json.DecodeIP(d) - elemElem = v - if err != nil { + var elemElem NilIP + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -30688,8 +31828,8 @@ func (s *Server) decodeTestRequestStringIpv6ArrayArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringIpv6NullableRequest(r *http.Request, span trace.Span) ( - req OptNilIPv6, +func (s *Server) decodeTestRequestStringInt32Request(r *http.Request, span trace.Span) ( + req OptStringInt32, close func() error, rerr error, ) { @@ -30722,7 +31862,7 @@ func (s *Server) decodeTestRequestStringIpv6NullableRequest(r *http.Request, spa return req, close, nil } - var request OptNilIPv6 + var request OptStringInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30748,8 +31888,8 @@ func (s *Server) decodeTestRequestStringIpv6NullableRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringIpv6NullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilIPv6, +func (s *Server) decodeTestRequestStringInt32ArrayRequest(r *http.Request, span trace.Span) ( + req []int32, close func() error, rerr error, ) { @@ -30782,7 +31922,7 @@ func (s *Server) decodeTestRequestStringIpv6NullableArrayRequest(r *http.Request return req, close, nil } - var request []NilIPv6 + var request []int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30794,10 +31934,12 @@ func (s *Server) decodeTestRequestStringIpv6NullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilIPv6, 0) + request = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIPv6 - if err := elem.Decode(d); err != nil { + var elem int32 + v, err := json.DecodeStringInt32(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -30815,8 +31957,8 @@ func (s *Server) decodeTestRequestStringIpv6NullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringIpv6NullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilIPv6, +func (s *Server) decodeTestRequestStringInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int32, close func() error, rerr error, ) { @@ -30849,7 +31991,7 @@ func (s *Server) decodeTestRequestStringIpv6NullableArrayArrayRequest(r *http.Re return req, close, nil } - var request [][]NilIPv6 + var request [][]int32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30861,13 +32003,15 @@ func (s *Server) decodeTestRequestStringIpv6NullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilIPv6, 0) + request = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIPv6 - elem = make([]NilIPv6, 0) + var elem []int32 + elem = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIPv6 - if err := elemElem.Decode(d); err != nil { + var elemElem int32 + v, err := json.DecodeStringInt32(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -30912,8 +32056,8 @@ func (s *Server) decodeTestRequestStringIpv6NullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request, span trace.Span) ( - req OptNilString, +func (s *Server) decodeTestRequestStringInt32NullableRequest(r *http.Request, span trace.Span) ( + req OptNilStringInt32, close func() error, rerr error, ) { @@ -30946,7 +32090,7 @@ func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request, span tr return req, close, nil } - var request OptNilString + var request OptNilStringInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -30972,8 +32116,8 @@ func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestStringInt32NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringInt32, close func() error, rerr error, ) { @@ -31006,7 +32150,7 @@ func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request, sp return req, close, nil } - var request []NilString + var request []NilStringInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31018,9 +32162,9 @@ func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString + var elem NilStringInt32 if err := elem.Decode(d); err != nil { return err } @@ -31039,8 +32183,8 @@ func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestStringInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringInt32, close func() error, rerr error, ) { @@ -31073,7 +32217,7 @@ func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Reques return req, close, nil } - var request [][]NilString + var request [][]NilStringInt32 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31085,12 +32229,12 @@ func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []NilStringInt32 + elem = make([]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString + var elemElem NilStringInt32 if err := elemElem.Decode(d); err != nil { return err } @@ -31136,8 +32280,8 @@ func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request, span trace.Span) ( - req OptString, +func (s *Server) decodeTestRequestStringInt64Request(r *http.Request, span trace.Span) ( + req OptStringInt64, close func() error, rerr error, ) { @@ -31170,7 +32314,7 @@ func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request, span tr return req, close, nil } - var request OptString + var request OptStringInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31196,8 +32340,8 @@ func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request, span trace.Span) ( - req []string, +func (s *Server) decodeTestRequestStringInt64ArrayRequest(r *http.Request, span trace.Span) ( + req []int64, close func() error, rerr error, ) { @@ -31230,7 +32374,7 @@ func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request, sp return req, close, nil } - var request []string + var request []int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31242,11 +32386,11 @@ func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]string, 0) + request = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) + var elem int64 + v, err := json.DecodeStringInt64(d) + elem = v if err != nil { return err } @@ -31265,8 +32409,8 @@ func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]string, +func (s *Server) decodeTestRequestStringInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]int64, close func() error, rerr error, ) { @@ -31299,7 +32443,7 @@ func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Reques return req, close, nil } - var request [][]string + var request [][]int64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31311,14 +32455,14 @@ func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]string, 0) + request = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []int64 + elem = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem string - v, err := d.Str() - elemElem = string(v) + var elemElem int64 + v, err := json.DecodeStringInt64(d) + elemElem = v if err != nil { return err } @@ -31364,8 +32508,8 @@ func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringPasswordNullableRequest(r *http.Request, span trace.Span) ( - req OptNilString, +func (s *Server) decodeTestRequestStringInt64NullableRequest(r *http.Request, span trace.Span) ( + req OptNilStringInt64, close func() error, rerr error, ) { @@ -31398,7 +32542,7 @@ func (s *Server) decodeTestRequestStringPasswordNullableRequest(r *http.Request, return req, close, nil } - var request OptNilString + var request OptNilStringInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31424,8 +32568,8 @@ func (s *Server) decodeTestRequestStringPasswordNullableRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilString, +func (s *Server) decodeTestRequestStringInt64NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringInt64, close func() error, rerr error, ) { @@ -31458,7 +32602,7 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Req return req, close, nil } - var request []NilString + var request []NilStringInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31470,9 +32614,9 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilString, 0) + request = make([]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString + var elem NilStringInt64 if err := elem.Decode(d); err != nil { return err } @@ -31491,8 +32635,8 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilString, +func (s *Server) decodeTestRequestStringInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringInt64, close func() error, rerr error, ) { @@ -31525,7 +32669,7 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *htt return req, close, nil } - var request [][]NilString + var request [][]NilStringInt64 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31537,12 +32681,12 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilString, 0) + request = make([][]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []NilStringInt64 + elem = make([]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString + var elemElem NilStringInt64 if err := elemElem.Decode(d); err != nil { return err } @@ -31588,8 +32732,8 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request, span trace.Span) ( - req OptTime, +func (s *Server) decodeTestRequestStringIpv4Request(r *http.Request, span trace.Span) ( + req OptIPv4, close func() error, rerr error, ) { @@ -31622,7 +32766,7 @@ func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request, span trace. return req, close, nil } - var request OptTime + var request OptIPv4 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31635,7 +32779,7 @@ func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request, span trace. d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeTime); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -31648,8 +32792,8 @@ func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request, span trace. } } -func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestStringIpv4ArrayRequest(r *http.Request, span trace.Span) ( + req []netip.Addr, close func() error, rerr error, ) { @@ -31682,7 +32826,7 @@ func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request, span t return req, close, nil } - var request []time.Time + var request []netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31694,10 +32838,10 @@ func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeTime(d) + var elem netip.Addr + v, err := json.DecodeIP(d) elem = v if err != nil { return err @@ -31717,8 +32861,8 @@ func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringIpv4ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]netip.Addr, close func() error, rerr error, ) { @@ -31751,7 +32895,7 @@ func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request, s return req, close, nil } - var request [][]time.Time + var request [][]netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31763,13 +32907,13 @@ func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []netip.Addr + elem = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeTime(d) + var elemElem netip.Addr + v, err := json.DecodeIP(d) elemElem = v if err != nil { return err @@ -31816,8 +32960,8 @@ func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request, span trace.Span) ( - req OptNilTime, +func (s *Server) decodeTestRequestStringIpv4NullableRequest(r *http.Request, span trace.Span) ( + req OptNilIPv4, close func() error, rerr error, ) { @@ -31850,7 +32994,7 @@ func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request, spa return req, close, nil } - var request OptNilTime + var request OptNilIPv4 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31863,7 +33007,7 @@ func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request, spa d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeTime); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -31876,8 +33020,8 @@ func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilTime, +func (s *Server) decodeTestRequestStringIpv4NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilIPv4, close func() error, rerr error, ) { @@ -31910,7 +33054,7 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request return req, close, nil } - var request []NilTime + var request []NilIPv4 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31922,10 +33066,10 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilTime, 0) + request = make([]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilTime - if err := elem.Decode(d, json.DecodeTime); err != nil { + var elem NilIPv4 + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -31943,8 +33087,8 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilTime, +func (s *Server) decodeTestRequestStringIpv4NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilIPv4, close func() error, rerr error, ) { @@ -31977,7 +33121,7 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Re return req, close, nil } - var request [][]NilTime + var request [][]NilIPv4 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -31989,13 +33133,13 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilTime, 0) + request = make([][]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilTime - elem = make([]NilTime, 0) + var elem []NilIPv4 + elem = make([]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilTime - if err := elemElem.Decode(d, json.DecodeTime); err != nil { + var elemElem NilIPv4 + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -32040,8 +33184,8 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringURIRequest(r *http.Request, span trace.Span) ( - req OptURI, +func (s *Server) decodeTestRequestStringIpv6Request(r *http.Request, span trace.Span) ( + req OptIPv6, close func() error, rerr error, ) { @@ -32074,7 +33218,7 @@ func (s *Server) decodeTestRequestStringURIRequest(r *http.Request, span trace.S return req, close, nil } - var request OptURI + var request OptIPv6 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32100,8 +33244,8 @@ func (s *Server) decodeTestRequestStringURIRequest(r *http.Request, span trace.S } } -func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request, span trace.Span) ( - req []url.URL, +func (s *Server) decodeTestRequestStringIpv6ArrayRequest(r *http.Request, span trace.Span) ( + req []netip.Addr, close func() error, rerr error, ) { @@ -32134,7 +33278,7 @@ func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request, span tr return req, close, nil } - var request []url.URL + var request []netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32146,10 +33290,10 @@ func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request, span tr d := jx.DecodeBytes(buf) if err := func() error { - request = make([]url.URL, 0) + request = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem url.URL - v, err := json.DecodeURI(d) + var elem netip.Addr + v, err := json.DecodeIP(d) elem = v if err != nil { return err @@ -32169,8 +33313,8 @@ func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]url.URL, +func (s *Server) decodeTestRequestStringIpv6ArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]netip.Addr, close func() error, rerr error, ) { @@ -32203,7 +33347,7 @@ func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request, sp return req, close, nil } - var request [][]url.URL + var request [][]netip.Addr buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32215,13 +33359,13 @@ func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]url.URL, 0) + request = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []url.URL - elem = make([]url.URL, 0) + var elem []netip.Addr + elem = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem url.URL - v, err := json.DecodeURI(d) + var elemElem netip.Addr + v, err := json.DecodeIP(d) elemElem = v if err != nil { return err @@ -32268,8 +33412,8 @@ func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request, span trace.Span) ( - req OptNilURI, +func (s *Server) decodeTestRequestStringIpv6NullableRequest(r *http.Request, span trace.Span) ( + req OptNilIPv6, close func() error, rerr error, ) { @@ -32302,7 +33446,7 @@ func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request, span return req, close, nil } - var request OptNilURI + var request OptNilIPv6 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32328,8 +33472,8 @@ func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilURI, +func (s *Server) decodeTestRequestStringIpv6NullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilIPv6, close func() error, rerr error, ) { @@ -32362,7 +33506,7 @@ func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request, return req, close, nil } - var request []NilURI + var request []NilIPv6 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32374,9 +33518,9 @@ func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilURI, 0) + request = make([]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilURI + var elem NilIPv6 if err := elem.Decode(d); err != nil { return err } @@ -32395,8 +33539,8 @@ func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilURI, +func (s *Server) decodeTestRequestStringIpv6NullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilIPv6, close func() error, rerr error, ) { @@ -32429,7 +33573,7 @@ func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Req return req, close, nil } - var request [][]NilURI + var request [][]NilIPv6 buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32441,12 +33585,12 @@ func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilURI, 0) + request = make([][]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilURI - elem = make([]NilURI, 0) + var elem []NilIPv6 + elem = make([]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilURI + var elemElem NilIPv6 if err := elemElem.Decode(d); err != nil { return err } @@ -32492,8 +33636,8 @@ func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request, span trace.Span) ( - req OptUUID, +func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request, span trace.Span) ( + req OptNilString, close func() error, rerr error, ) { @@ -32526,7 +33670,7 @@ func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request, span trace. return req, close, nil } - var request OptUUID + var request OptNilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32552,8 +33696,8 @@ func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request, span trace. } } -func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request, span trace.Span) ( - req []uuid.UUID, +func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -32586,7 +33730,7 @@ func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request, span t return req, close, nil } - var request []uuid.UUID + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32598,12 +33742,10 @@ func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { - request = make([]uuid.UUID, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uuid.UUID - v, err := json.DecodeUUID(d) - elem = v - if err != nil { + var elem NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -32621,8 +33763,8 @@ func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]uuid.UUID, +func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -32655,7 +33797,7 @@ func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request, s return req, close, nil } - var request [][]uuid.UUID + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32667,15 +33809,13 @@ func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]uuid.UUID, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uuid.UUID - elem = make([]uuid.UUID, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uuid.UUID - v, err := json.DecodeUUID(d) - elemElem = v - if err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -32720,8 +33860,8 @@ func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request, span trace.Span) ( - req OptNilUUID, +func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request, span trace.Span) ( + req OptString, close func() error, rerr error, ) { @@ -32754,7 +33894,7 @@ func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request, spa return req, close, nil } - var request OptNilUUID + var request OptString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32780,8 +33920,8 @@ func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilUUID, +func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request, span trace.Span) ( + req []string, close func() error, rerr error, ) { @@ -32814,7 +33954,7 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request return req, close, nil } - var request []NilUUID + var request []string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32826,10 +33966,12 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilUUID, 0) + request = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUUID - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } request = append(request, elem) @@ -32847,8 +33989,8 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilUUID, +func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]string, close func() error, rerr error, ) { @@ -32881,7 +34023,7 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Re return req, close, nil } - var request [][]NilUUID + var request [][]string buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32893,13 +34035,15 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilUUID, 0) + request = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUUID - elem = make([]NilUUID, 0) + var elem []string + elem = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUUID - if err := elemElem.Decode(d); err != nil { + var elemElem string + v, err := d.Str() + elemElem = string(v) + if err != nil { return err } elem = append(elem, elemElem) @@ -32944,8 +34088,8 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request, span trace.Span) ( - req OptStringUnixSeconds, +func (s *Server) decodeTestRequestStringPasswordNullableRequest(r *http.Request, span trace.Span) ( + req OptNilString, close func() error, rerr error, ) { @@ -32978,7 +34122,7 @@ func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request, span trace. return req, close, nil } - var request OptStringUnixSeconds + var request OptNilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -32991,7 +34135,7 @@ func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request, span trace. d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -33004,8 +34148,8 @@ func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request, span trace. } } -func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilString, close func() error, rerr error, ) { @@ -33038,7 +34182,7 @@ func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request, span t return req, close, nil } - var request []time.Time + var request []NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33050,12 +34194,10 @@ func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixSeconds(d) - elem = v - if err != nil { + var elem NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -33073,8 +34215,8 @@ func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilString, close func() error, rerr error, ) { @@ -33107,7 +34249,7 @@ func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request, s return req, close, nil } - var request [][]time.Time + var request [][]NilString buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33119,15 +34261,13 @@ func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixSeconds(d) - elemElem = v - if err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -33172,8 +34312,8 @@ func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request, span trace.Span) ( - req OptStringUnixMicro, +func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request, span trace.Span) ( + req OptTime, close func() error, rerr error, ) { @@ -33206,7 +34346,7 @@ func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request, span t return req, close, nil } - var request OptStringUnixMicro + var request OptTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33219,7 +34359,7 @@ func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { + if err := request.Decode(d, json.DecodeTime); err != nil { return err } return nil @@ -33232,7 +34372,7 @@ func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request, span trace.Span) ( req []time.Time, close func() error, rerr error, @@ -33281,7 +34421,7 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request, s request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem time.Time - v, err := json.DecodeStringUnixMicro(d) + v, err := json.DecodeTime(d) elem = v if err != nil { return err @@ -33301,7 +34441,7 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request, span trace.Span) ( req [][]time.Time, close func() error, rerr error, @@ -33353,7 +34493,7 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Reque elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elemElem time.Time - v, err := json.DecodeStringUnixMicro(d) + v, err := json.DecodeTime(d) elemElem = v if err != nil { return err @@ -33400,8 +34540,8 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request, span trace.Span) ( - req OptNilStringUnixMicro, +func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request, span trace.Span) ( + req OptNilTime, close func() error, rerr error, ) { @@ -33434,7 +34574,7 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request return req, close, nil } - var request OptNilStringUnixMicro + var request OptNilTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33447,7 +34587,7 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { + if err := request.Decode(d, json.DecodeTime); err != nil { return err } return nil @@ -33460,8 +34600,8 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixMicro, +func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilTime, close func() error, rerr error, ) { @@ -33494,7 +34634,7 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Re return req, close, nil } - var request []NilStringUnixMicro + var request []NilTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33506,10 +34646,10 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixMicro, 0) + request = make([]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixMicro - if err := elem.Decode(d, json.DecodeStringUnixMicro); err != nil { + var elem NilTime + if err := elem.Decode(d, json.DecodeTime); err != nil { return err } request = append(request, elem) @@ -33527,8 +34667,8 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixMicro, +func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilTime, close func() error, rerr error, ) { @@ -33561,7 +34701,7 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *ht return req, close, nil } - var request [][]NilStringUnixMicro + var request [][]NilTime buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33573,13 +34713,13 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixMicro, 0) + request = make([][]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixMicro - elem = make([]NilStringUnixMicro, 0) + var elem []NilTime + elem = make([]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixMicro - if err := elemElem.Decode(d, json.DecodeStringUnixMicro); err != nil { + var elemElem NilTime + if err := elemElem.Decode(d, json.DecodeTime); err != nil { return err } elem = append(elem, elemElem) @@ -33624,8 +34764,8 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request, span trace.Span) ( - req OptStringUnixMilli, +func (s *Server) decodeTestRequestStringURIRequest(r *http.Request, span trace.Span) ( + req OptURI, close func() error, rerr error, ) { @@ -33658,7 +34798,7 @@ func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request, span t return req, close, nil } - var request OptStringUnixMilli + var request OptURI buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33671,7 +34811,7 @@ func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request, span t d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -33684,8 +34824,8 @@ func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request, span t } } -func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request, span trace.Span) ( + req []url.URL, close func() error, rerr error, ) { @@ -33718,7 +34858,7 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request, s return req, close, nil } - var request []time.Time + var request []url.URL buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33730,10 +34870,10 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request, s d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixMilli(d) + var elem url.URL + v, err := json.DecodeURI(d) elem = v if err != nil { return err @@ -33753,8 +34893,8 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request, s } } -func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]url.URL, close func() error, rerr error, ) { @@ -33787,7 +34927,7 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Reque return req, close, nil } - var request [][]time.Time + var request [][]url.URL buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33799,13 +34939,13 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []url.URL + elem = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixMilli(d) + var elemElem url.URL + v, err := json.DecodeURI(d) elemElem = v if err != nil { return err @@ -33852,8 +34992,8 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request, span trace.Span) ( - req OptNilStringUnixMilli, +func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request, span trace.Span) ( + req OptNilURI, close func() error, rerr error, ) { @@ -33886,7 +35026,7 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request return req, close, nil } - var request OptNilStringUnixMilli + var request OptNilURI buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33899,7 +35039,7 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -33912,8 +35052,8 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixMilli, +func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilURI, close func() error, rerr error, ) { @@ -33946,7 +35086,7 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Re return req, close, nil } - var request []NilStringUnixMilli + var request []NilURI buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -33958,10 +35098,10 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixMilli, 0) + request = make([]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixMilli - if err := elem.Decode(d, json.DecodeStringUnixMilli); err != nil { + var elem NilURI + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -33979,8 +35119,8 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixMilli, +func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilURI, close func() error, rerr error, ) { @@ -34013,7 +35153,7 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *ht return req, close, nil } - var request [][]NilStringUnixMilli + var request [][]NilURI buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34025,13 +35165,13 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixMilli, 0) + request = make([][]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixMilli - elem = make([]NilStringUnixMilli, 0) + var elem []NilURI + elem = make([]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixMilli - if err := elemElem.Decode(d, json.DecodeStringUnixMilli); err != nil { + var elemElem NilURI + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -34076,8 +35216,8 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request, span trace.Span) ( - req OptStringUnixNano, +func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request, span trace.Span) ( + req OptUUID, close func() error, rerr error, ) { @@ -34110,7 +35250,7 @@ func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request, span tr return req, close, nil } - var request OptStringUnixNano + var request OptUUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34123,7 +35263,7 @@ func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request, span tr d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -34136,8 +35276,8 @@ func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request, span tr } } -func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request, span trace.Span) ( - req []time.Time, +func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request, span trace.Span) ( + req []uuid.UUID, close func() error, rerr error, ) { @@ -34170,7 +35310,7 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request, sp return req, close, nil } - var request []time.Time + var request []uuid.UUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34182,10 +35322,10 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request, sp d := jx.DecodeBytes(buf) if err := func() error { - request = make([]time.Time, 0) + request = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixNano(d) + var elem uuid.UUID + v, err := json.DecodeUUID(d) elem = v if err != nil { return err @@ -34205,8 +35345,8 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request, sp } } -func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]uuid.UUID, close func() error, rerr error, ) { @@ -34239,7 +35379,7 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Reques return req, close, nil } - var request [][]time.Time + var request [][]uuid.UUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34251,13 +35391,13 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]time.Time, 0) + request = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []uuid.UUID + elem = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixNano(d) + var elemElem uuid.UUID + v, err := json.DecodeUUID(d) elemElem = v if err != nil { return err @@ -34304,8 +35444,8 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request, span trace.Span) ( - req OptNilStringUnixNano, +func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request, span trace.Span) ( + req OptNilUUID, close func() error, rerr error, ) { @@ -34338,7 +35478,7 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request, return req, close, nil } - var request OptNilStringUnixNano + var request OptNilUUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34351,7 +35491,7 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request, d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { + if err := request.Decode(d); err != nil { return err } return nil @@ -34364,8 +35504,8 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixNano, +func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilUUID, close func() error, rerr error, ) { @@ -34398,7 +35538,7 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Req return req, close, nil } - var request []NilStringUnixNano + var request []NilUUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34410,10 +35550,10 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixNano, 0) + request = make([]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixNano - if err := elem.Decode(d, json.DecodeStringUnixNano); err != nil { + var elem NilUUID + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -34431,8 +35571,8 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixNano, +func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilUUID, close func() error, rerr error, ) { @@ -34465,7 +35605,7 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *htt return req, close, nil } - var request [][]NilStringUnixNano + var request [][]NilUUID buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34477,13 +35617,13 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixNano, 0) + request = make([][]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixNano - elem = make([]NilStringUnixNano, 0) + var elem []NilUUID + elem = make([]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixNano - if err := elemElem.Decode(d, json.DecodeStringUnixNano); err != nil { + var elemElem NilUUID + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -34528,8 +35668,8 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request, span trace.Span) ( - req OptNilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request, span trace.Span) ( + req OptStringUnixSeconds, close func() error, rerr error, ) { @@ -34562,7 +35702,7 @@ func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request, spa return req, close, nil } - var request OptNilStringUnixSeconds + var request OptStringUnixSeconds buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34588,8 +35728,8 @@ func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request, spa } } -func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -34622,7 +35762,7 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request return req, close, nil } - var request []NilStringUnixSeconds + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34634,10 +35774,12 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixSeconds, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixSeconds - if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elem time.Time + v, err := json.DecodeStringUnixSeconds(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -34655,8 +35797,8 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -34689,7 +35831,7 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Re return req, close, nil } - var request [][]NilStringUnixSeconds + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34701,13 +35843,15 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixSeconds, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixSeconds - elem = make([]NilStringUnixSeconds, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixSeconds - if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elemElem time.Time + v, err := json.DecodeStringUnixSeconds(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -34752,8 +35896,8 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request, span trace.Span) ( - req OptStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request, span trace.Span) ( + req OptStringUnixMicro, close func() error, rerr error, ) { @@ -34786,7 +35930,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request, span return req, close, nil } - var request OptStringUnixSeconds + var request OptStringUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -34799,7 +35943,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request, span d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { return err } return nil @@ -34812,7 +35956,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request, span } } -func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request, span trace.Span) ( req []time.Time, close func() error, rerr error, @@ -34861,7 +36005,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request, request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem time.Time - v, err := json.DecodeStringUnixSeconds(d) + v, err := json.DecodeStringUnixMicro(d) elem = v if err != nil { return err @@ -34881,7 +36025,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request, } } -func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Request, span trace.Span) ( req [][]time.Time, close func() error, rerr error, @@ -34933,7 +36077,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Req elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elemElem time.Time - v, err := json.DecodeStringUnixSeconds(d) + v, err := json.DecodeStringUnixMicro(d) elemElem = v if err != nil { return err @@ -34980,8 +36124,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( - req OptNilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request, span trace.Span) ( + req OptNilStringUnixMicro, close func() error, rerr error, ) { @@ -35014,7 +36158,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Reque return req, close, nil } - var request OptNilStringUnixSeconds + var request OptNilStringUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -35027,7 +36171,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Reque d := jx.DecodeBytes(buf) if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { return err } return nil @@ -35040,8 +36184,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( - req []NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixMicro, close func() error, rerr error, ) { @@ -35074,7 +36218,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http. return req, close, nil } - var request []NilStringUnixSeconds + var request []NilStringUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -35086,10 +36230,10 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http. d := jx.DecodeBytes(buf) if err := func() error { - request = make([]NilStringUnixSeconds, 0) + request = make([]NilStringUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixSeconds - if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elem NilStringUnixMicro + if err := elem.Decode(d, json.DecodeStringUnixMicro); err != nil { return err } request = append(request, elem) @@ -35107,8 +36251,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http. } } -func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( - req [][]NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixMicro, close func() error, rerr error, ) { @@ -35141,7 +36285,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r * return req, close, nil } - var request [][]NilStringUnixSeconds + var request [][]NilStringUnixMicro buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err @@ -35153,13 +36297,13 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r * d := jx.DecodeBytes(buf) if err := func() error { - request = make([][]NilStringUnixSeconds, 0) + request = make([][]NilStringUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixSeconds - elem = make([]NilStringUnixSeconds, 0) + var elem []NilStringUnixMicro + elem = make([]NilStringUnixMicro, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixSeconds - if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elemElem NilStringUnixMicro + if err := elemElem.Decode(d, json.DecodeStringUnixMicro); err != nil { return err } elem = append(elem, elemElem) @@ -35204,8 +36348,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r * } } -func (s *Server) decodeTestResponseAnyRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request, span trace.Span) ( + req OptStringUnixMilli, close func() error, rerr error, ) { @@ -35224,6 +36368,9 @@ func (s *Server) decodeTestResponseAnyRequest(r *http.Request, span trace.Span) rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -35232,24 +36379,23 @@ func (s *Server) decodeTestResponseAnyRequest(r *http.Request, span trace.Span) switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request string + var request OptStringUnixMilli buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } return nil @@ -35262,8 +36408,8 @@ func (s *Server) decodeTestResponseAnyRequest(r *http.Request, span trace.Span) } } -func (s *Server) decodeTestResponseBooleanRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, close func() error, rerr error, ) { @@ -35282,6 +36428,9 @@ func (s *Server) decodeTestResponseBooleanRequest(r *http.Request, span trace.Sp rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -35290,24 +36439,32 @@ func (s *Server) decodeTestResponseBooleanRequest(r *http.Request, span trace.Sp switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request string + var request []time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + request = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem time.Time + v, err := json.DecodeStringUnixMilli(d) + elem = v + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { return err } return nil @@ -35320,8 +36477,8 @@ func (s *Server) decodeTestResponseBooleanRequest(r *http.Request, span trace.Sp } } -func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request, span trace.Span) ( - req string, +func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -35340,6 +36497,9 @@ func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request, span tra rerr = multierr.Append(rerr, close()) } }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) if err != nil { @@ -35348,24 +36508,122 @@ func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request, span tra switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } - var request string + var request [][]time.Time buf, err := io.ReadAll(r.Body) if err != nil { return req, close, err } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + request = make([][]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []time.Time + elem = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem time.Time + v, err := json.DecodeStringUnixMilli(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request, span trace.Span) ( + req OptNilStringUnixMilli, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request OptNilStringUnixMilli + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } return nil @@ -35378,7 +36636,2285 @@ func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request, span tra } } -func (s *Server) decodeTestResponseBooleanArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixMilli, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []NilStringUnixMilli + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]NilStringUnixMilli, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilStringUnixMilli + if err := elem.Decode(d, json.DecodeStringUnixMilli); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixMilli, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]NilStringUnixMilli + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilStringUnixMilli, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilStringUnixMilli + elem = make([]NilStringUnixMilli, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilStringUnixMilli + if err := elemElem.Decode(d, json.DecodeStringUnixMilli); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request, span trace.Span) ( + req OptStringUnixNano, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request OptStringUnixNano + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []time.Time + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem time.Time + v, err := json.DecodeStringUnixNano(d) + elem = v + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]time.Time + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []time.Time + elem = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem time.Time + v, err := json.DecodeStringUnixNano(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request, span trace.Span) ( + req OptNilStringUnixNano, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request OptNilStringUnixNano + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixNano, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []NilStringUnixNano + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]NilStringUnixNano, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilStringUnixNano + if err := elem.Decode(d, json.DecodeStringUnixNano); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixNano, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]NilStringUnixNano + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilStringUnixNano, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilStringUnixNano + elem = make([]NilStringUnixNano, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilStringUnixNano + if err := elemElem.Decode(d, json.DecodeStringUnixNano); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request, span trace.Span) ( + req OptNilStringUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request OptNilStringUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []NilStringUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]NilStringUnixSeconds, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilStringUnixSeconds + if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]NilStringUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilStringUnixSeconds, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilStringUnixSeconds + elem = make([]NilStringUnixSeconds, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilStringUnixSeconds + if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request, span trace.Span) ( + req OptStringUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request OptStringUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request, span trace.Span) ( + req []time.Time, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []time.Time + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem time.Time + v, err := json.DecodeStringUnixSeconds(d) + elem = v + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]time.Time, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]time.Time + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []time.Time + elem = make([]time.Time, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem time.Time + v, err := json.DecodeStringUnixSeconds(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Request, span trace.Span) ( + req OptNilStringUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request OptNilStringUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http.Request, span trace.Span) ( + req []NilStringUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request []NilStringUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([]NilStringUnixSeconds, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilStringUnixSeconds + if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req [][]NilStringUnixSeconds, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { + return req, close, nil + } + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, nil + } + + var request [][]NilStringUnixSeconds + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, nil + } + + d := jx.DecodeBytes(buf) + if err := func() error { + request = make([][]NilStringUnixSeconds, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilStringUnixSeconds + elem = make([]NilStringUnixSeconds, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilStringUnixSeconds + if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range request { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "validate") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseAnyRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseBooleanRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseBooleanArrayArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseBooleanNullableRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseBooleanNullableArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseBooleanNullableArrayArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseEmptyStructRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseFormatTestRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerArrayArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerInt32Request(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerInt32ArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerInt32NullableRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerInt32NullableArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35436,7 +38972,7 @@ func (s *Server) decodeTestResponseBooleanArrayArrayRequest(r *http.Request, spa } } -func (s *Server) decodeTestResponseBooleanNullableRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerInt64Request(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35494,7 +39030,7 @@ func (s *Server) decodeTestResponseBooleanNullableRequest(r *http.Request, span } } -func (s *Server) decodeTestResponseBooleanNullableArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerInt64ArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35552,7 +39088,7 @@ func (s *Server) decodeTestResponseBooleanNullableArrayRequest(r *http.Request, } } -func (s *Server) decodeTestResponseBooleanNullableArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35610,7 +39146,7 @@ func (s *Server) decodeTestResponseBooleanNullableArrayArrayRequest(r *http.Requ } } -func (s *Server) decodeTestResponseEmptyStructRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerInt64NullableRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35668,7 +39204,7 @@ func (s *Server) decodeTestResponseEmptyStructRequest(r *http.Request, span trac } } -func (s *Server) decodeTestResponseFormatTestRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerInt64NullableArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35726,7 +39262,7 @@ func (s *Server) decodeTestResponseFormatTestRequest(r *http.Request, span trace } } -func (s *Server) decodeTestResponseIntegerRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35784,7 +39320,7 @@ func (s *Server) decodeTestResponseIntegerRequest(r *http.Request, span trace.Sp } } -func (s *Server) decodeTestResponseIntegerArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerNullableRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35842,7 +39378,7 @@ func (s *Server) decodeTestResponseIntegerArrayRequest(r *http.Request, span tra } } -func (s *Server) decodeTestResponseIntegerArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerNullableArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35900,7 +39436,7 @@ func (s *Server) decodeTestResponseIntegerArrayArrayRequest(r *http.Request, spa } } -func (s *Server) decodeTestResponseIntegerInt32Request(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerNullableArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -35958,7 +39494,7 @@ func (s *Server) decodeTestResponseIntegerInt32Request(r *http.Request, span tra } } -func (s *Server) decodeTestResponseIntegerInt32ArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUintRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36016,7 +39552,7 @@ func (s *Server) decodeTestResponseIntegerInt32ArrayRequest(r *http.Request, spa } } -func (s *Server) decodeTestResponseIntegerInt32ArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint32Request(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36074,7 +39610,7 @@ func (s *Server) decodeTestResponseIntegerInt32ArrayArrayRequest(r *http.Request } } -func (s *Server) decodeTestResponseIntegerInt32NullableRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint32ArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36132,7 +39668,7 @@ func (s *Server) decodeTestResponseIntegerInt32NullableRequest(r *http.Request, } } -func (s *Server) decodeTestResponseIntegerInt32NullableArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint32ArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36190,7 +39726,7 @@ func (s *Server) decodeTestResponseIntegerInt32NullableArrayRequest(r *http.Requ } } -func (s *Server) decodeTestResponseIntegerInt32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint32NullableRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36248,7 +39784,7 @@ func (s *Server) decodeTestResponseIntegerInt32NullableArrayArrayRequest(r *http } } -func (s *Server) decodeTestResponseIntegerInt64Request(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint32NullableArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36306,7 +39842,7 @@ func (s *Server) decodeTestResponseIntegerInt64Request(r *http.Request, span tra } } -func (s *Server) decodeTestResponseIntegerInt64ArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint32NullableArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36364,7 +39900,7 @@ func (s *Server) decodeTestResponseIntegerInt64ArrayRequest(r *http.Request, spa } } -func (s *Server) decodeTestResponseIntegerInt64ArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint64Request(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36422,7 +39958,7 @@ func (s *Server) decodeTestResponseIntegerInt64ArrayArrayRequest(r *http.Request } } -func (s *Server) decodeTestResponseIntegerInt64NullableRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint64ArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36480,7 +40016,7 @@ func (s *Server) decodeTestResponseIntegerInt64NullableRequest(r *http.Request, } } -func (s *Server) decodeTestResponseIntegerInt64NullableArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint64ArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36538,7 +40074,7 @@ func (s *Server) decodeTestResponseIntegerInt64NullableArrayRequest(r *http.Requ } } -func (s *Server) decodeTestResponseIntegerInt64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint64NullableRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36596,7 +40132,7 @@ func (s *Server) decodeTestResponseIntegerInt64NullableArrayArrayRequest(r *http } } -func (s *Server) decodeTestResponseIntegerNullableRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint64NullableArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36654,7 +40190,7 @@ func (s *Server) decodeTestResponseIntegerNullableRequest(r *http.Request, span } } -func (s *Server) decodeTestResponseIntegerNullableArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUint64NullableArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, @@ -36712,7 +40248,239 @@ func (s *Server) decodeTestResponseIntegerNullableArrayRequest(r *http.Request, } } -func (s *Server) decodeTestResponseIntegerNullableArrayArrayRequest(r *http.Request, span trace.Span) ( +func (s *Server) decodeTestResponseIntegerUintArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerUintArrayArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerUintNullableRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerUintNullableArrayRequest(r *http.Request, span trace.Span) ( + req string, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = multierr.Append(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = multierr.Append(rerr, close()) + } + }() + + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, close, validate.ErrBodyRequired + } + + var request string + buf, err := io.ReadAll(r.Body) + if err != nil { + return req, close, err + } + + if len(buf) == 0 { + return req, close, validate.ErrBodyRequired + } + + d := jx.DecodeBytes(buf) + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return req, close, errors.Wrap(err, "decode \"application/json\"") + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerUintNullableArrayArrayRequest(r *http.Request, span trace.Span) ( req string, close func() error, rerr error, diff --git a/examples/ex_test_format/oas_request_encoders_gen.go b/examples/ex_test_format/oas_request_encoders_gen.go index e73f2e869..26e7a1566 100644 --- a/examples/ex_test_format/oas_request_encoders_gen.go +++ b/examples/ex_test_format/oas_request_encoders_gen.go @@ -566,8 +566,8 @@ func encodeTestRequestIntegerNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixRequest( - req OptUnixSeconds, +func encodeTestRequestIntegerUintRequest( + req OptUint, r *http.Request, ) error { const contentType = "application/json" @@ -578,15 +578,34 @@ func encodeTestRequestIntegerUnixRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixSeconds) + req.Encode(e) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixArrayRequest( - req []time.Time, +func encodeTestRequestIntegerUint32Request( + req OptUint32, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := jx.GetEncoder() + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestIntegerUint32ArrayRequest( + req []uint32, r *http.Request, ) error { const contentType = "application/json" @@ -595,7 +614,7 @@ func encodeTestRequestIntegerUnixArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - json.EncodeUnixSeconds(e, elem) + e.UInt32(elem) } e.ArrEnd() } @@ -604,8 +623,8 @@ func encodeTestRequestIntegerUnixArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixArrayArrayRequest( - req [][]time.Time, +func encodeTestRequestIntegerUint32ArrayArrayRequest( + req [][]uint32, r *http.Request, ) error { const contentType = "application/json" @@ -616,7 +635,7 @@ func encodeTestRequestIntegerUnixArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - json.EncodeUnixSeconds(e, elem) + e.UInt32(elem) } e.ArrEnd() } @@ -627,8 +646,8 @@ func encodeTestRequestIntegerUnixArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMicroRequest( - req OptUnixMicro, +func encodeTestRequestIntegerUint32NullableRequest( + req OptNilUint32, r *http.Request, ) error { const contentType = "application/json" @@ -639,15 +658,15 @@ func encodeTestRequestIntegerUnixMicroRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixMicro) + req.Encode(e) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMicroArrayRequest( - req []time.Time, +func encodeTestRequestIntegerUint32NullableArrayRequest( + req []NilUint32, r *http.Request, ) error { const contentType = "application/json" @@ -656,7 +675,7 @@ func encodeTestRequestIntegerUnixMicroArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - json.EncodeUnixMicro(e, elem) + elem.Encode(e) } e.ArrEnd() } @@ -665,8 +684,8 @@ func encodeTestRequestIntegerUnixMicroArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMicroArrayArrayRequest( - req [][]time.Time, +func encodeTestRequestIntegerUint32NullableArrayArrayRequest( + req [][]NilUint32, r *http.Request, ) error { const contentType = "application/json" @@ -677,7 +696,7 @@ func encodeTestRequestIntegerUnixMicroArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - json.EncodeUnixMicro(e, elem) + elem.Encode(e) } e.ArrEnd() } @@ -688,8 +707,8 @@ func encodeTestRequestIntegerUnixMicroArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMicroNullableRequest( - req OptNilUnixMicro, +func encodeTestRequestIntegerUint64Request( + req OptUint64, r *http.Request, ) error { const contentType = "application/json" @@ -700,15 +719,15 @@ func encodeTestRequestIntegerUnixMicroNullableRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixMicro) + req.Encode(e) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMicroNullableArrayRequest( - req []NilUnixMicro, +func encodeTestRequestIntegerUint64ArrayRequest( + req []uint64, r *http.Request, ) error { const contentType = "application/json" @@ -717,7 +736,7 @@ func encodeTestRequestIntegerUnixMicroNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e, json.EncodeUnixMicro) + e.UInt64(elem) } e.ArrEnd() } @@ -726,8 +745,8 @@ func encodeTestRequestIntegerUnixMicroNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMicroNullableArrayArrayRequest( - req [][]NilUnixMicro, +func encodeTestRequestIntegerUint64ArrayArrayRequest( + req [][]uint64, r *http.Request, ) error { const contentType = "application/json" @@ -738,7 +757,7 @@ func encodeTestRequestIntegerUnixMicroNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e, json.EncodeUnixMicro) + e.UInt64(elem) } e.ArrEnd() } @@ -749,8 +768,8 @@ func encodeTestRequestIntegerUnixMicroNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMilliRequest( - req OptUnixMilli, +func encodeTestRequestIntegerUint64NullableRequest( + req OptNilUint64, r *http.Request, ) error { const contentType = "application/json" @@ -761,15 +780,15 @@ func encodeTestRequestIntegerUnixMilliRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixMilli) + req.Encode(e) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMilliArrayRequest( - req []time.Time, +func encodeTestRequestIntegerUint64NullableArrayRequest( + req []NilUint64, r *http.Request, ) error { const contentType = "application/json" @@ -778,7 +797,7 @@ func encodeTestRequestIntegerUnixMilliArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - json.EncodeUnixMilli(e, elem) + elem.Encode(e) } e.ArrEnd() } @@ -787,8 +806,8 @@ func encodeTestRequestIntegerUnixMilliArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMilliArrayArrayRequest( - req [][]time.Time, +func encodeTestRequestIntegerUint64NullableArrayArrayRequest( + req [][]NilUint64, r *http.Request, ) error { const contentType = "application/json" @@ -799,7 +818,7 @@ func encodeTestRequestIntegerUnixMilliArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - json.EncodeUnixMilli(e, elem) + elem.Encode(e) } e.ArrEnd() } @@ -810,27 +829,8 @@ func encodeTestRequestIntegerUnixMilliArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMilliNullableRequest( - req OptNilUnixMilli, - r *http.Request, -) error { - const contentType = "application/json" - if !req.Set { - // Keep request with empty body if value is not set. - return nil - } - e := jx.GetEncoder() - { - if req.Set { - req.Encode(e, json.EncodeUnixMilli) - } - } - encoded := e.Bytes() - ht.SetBody(r, bytes.NewReader(encoded), contentType) - return nil -} -func encodeTestRequestIntegerUnixMilliNullableArrayRequest( - req []NilUnixMilli, +func encodeTestRequestIntegerUintArrayRequest( + req []uint, r *http.Request, ) error { const contentType = "application/json" @@ -839,7 +839,7 @@ func encodeTestRequestIntegerUnixMilliNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e, json.EncodeUnixMilli) + e.UInt(elem) } e.ArrEnd() } @@ -848,8 +848,8 @@ func encodeTestRequestIntegerUnixMilliNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixMilliNullableArrayArrayRequest( - req [][]NilUnixMilli, +func encodeTestRequestIntegerUintArrayArrayRequest( + req [][]uint, r *http.Request, ) error { const contentType = "application/json" @@ -860,7 +860,7 @@ func encodeTestRequestIntegerUnixMilliNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e, json.EncodeUnixMilli) + e.UInt(elem) } e.ArrEnd() } @@ -871,8 +871,8 @@ func encodeTestRequestIntegerUnixMilliNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNanoRequest( - req OptUnixNano, +func encodeTestRequestIntegerUintNullableRequest( + req OptNilUint, r *http.Request, ) error { const contentType = "application/json" @@ -883,15 +883,15 @@ func encodeTestRequestIntegerUnixNanoRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixNano) + req.Encode(e) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNanoArrayRequest( - req []time.Time, +func encodeTestRequestIntegerUintNullableArrayRequest( + req []NilUint, r *http.Request, ) error { const contentType = "application/json" @@ -900,7 +900,7 @@ func encodeTestRequestIntegerUnixNanoArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - json.EncodeUnixNano(e, elem) + elem.Encode(e) } e.ArrEnd() } @@ -909,8 +909,8 @@ func encodeTestRequestIntegerUnixNanoArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNanoArrayArrayRequest( - req [][]time.Time, +func encodeTestRequestIntegerUintNullableArrayArrayRequest( + req [][]NilUint, r *http.Request, ) error { const contentType = "application/json" @@ -921,7 +921,7 @@ func encodeTestRequestIntegerUnixNanoArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - json.EncodeUnixNano(e, elem) + elem.Encode(e) } e.ArrEnd() } @@ -932,8 +932,8 @@ func encodeTestRequestIntegerUnixNanoArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNanoNullableRequest( - req OptNilUnixNano, +func encodeTestRequestIntegerUnixRequest( + req OptUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -944,15 +944,15 @@ func encodeTestRequestIntegerUnixNanoNullableRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixNano) + req.Encode(e, json.EncodeUnixSeconds) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNanoNullableArrayRequest( - req []NilUnixNano, +func encodeTestRequestIntegerUnixArrayRequest( + req []time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -961,7 +961,7 @@ func encodeTestRequestIntegerUnixNanoNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e, json.EncodeUnixNano) + json.EncodeUnixSeconds(e, elem) } e.ArrEnd() } @@ -970,8 +970,8 @@ func encodeTestRequestIntegerUnixNanoNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNanoNullableArrayArrayRequest( - req [][]NilUnixNano, +func encodeTestRequestIntegerUnixArrayArrayRequest( + req [][]time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -982,7 +982,7 @@ func encodeTestRequestIntegerUnixNanoNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e, json.EncodeUnixNano) + json.EncodeUnixSeconds(e, elem) } e.ArrEnd() } @@ -993,8 +993,8 @@ func encodeTestRequestIntegerUnixNanoNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNullableRequest( - req OptNilUnixSeconds, +func encodeTestRequestIntegerUnixMicroRequest( + req OptUnixMicro, r *http.Request, ) error { const contentType = "application/json" @@ -1005,15 +1005,15 @@ func encodeTestRequestIntegerUnixNullableRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixSeconds) + req.Encode(e, json.EncodeUnixMicro) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNullableArrayRequest( - req []NilUnixSeconds, +func encodeTestRequestIntegerUnixMicroArrayRequest( + req []time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1022,7 +1022,7 @@ func encodeTestRequestIntegerUnixNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e, json.EncodeUnixSeconds) + json.EncodeUnixMicro(e, elem) } e.ArrEnd() } @@ -1031,8 +1031,8 @@ func encodeTestRequestIntegerUnixNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixNullableArrayArrayRequest( - req [][]NilUnixSeconds, +func encodeTestRequestIntegerUnixMicroArrayArrayRequest( + req [][]time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1043,7 +1043,7 @@ func encodeTestRequestIntegerUnixNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e, json.EncodeUnixSeconds) + json.EncodeUnixMicro(e, elem) } e.ArrEnd() } @@ -1054,8 +1054,8 @@ func encodeTestRequestIntegerUnixNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixSecondsRequest( - req OptUnixSeconds, +func encodeTestRequestIntegerUnixMicroNullableRequest( + req OptNilUnixMicro, r *http.Request, ) error { const contentType = "application/json" @@ -1066,15 +1066,15 @@ func encodeTestRequestIntegerUnixSecondsRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixSeconds) + req.Encode(e, json.EncodeUnixMicro) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixSecondsArrayRequest( - req []time.Time, +func encodeTestRequestIntegerUnixMicroNullableArrayRequest( + req []NilUnixMicro, r *http.Request, ) error { const contentType = "application/json" @@ -1083,7 +1083,7 @@ func encodeTestRequestIntegerUnixSecondsArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - json.EncodeUnixSeconds(e, elem) + elem.Encode(e, json.EncodeUnixMicro) } e.ArrEnd() } @@ -1092,8 +1092,8 @@ func encodeTestRequestIntegerUnixSecondsArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixSecondsArrayArrayRequest( - req [][]time.Time, +func encodeTestRequestIntegerUnixMicroNullableArrayArrayRequest( + req [][]NilUnixMicro, r *http.Request, ) error { const contentType = "application/json" @@ -1104,7 +1104,7 @@ func encodeTestRequestIntegerUnixSecondsArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - json.EncodeUnixSeconds(e, elem) + elem.Encode(e, json.EncodeUnixMicro) } e.ArrEnd() } @@ -1115,8 +1115,8 @@ func encodeTestRequestIntegerUnixSecondsArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixSecondsNullableRequest( - req OptNilUnixSeconds, +func encodeTestRequestIntegerUnixMilliRequest( + req OptUnixMilli, r *http.Request, ) error { const contentType = "application/json" @@ -1127,15 +1127,15 @@ func encodeTestRequestIntegerUnixSecondsNullableRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e, json.EncodeUnixSeconds) + req.Encode(e, json.EncodeUnixMilli) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixSecondsNullableArrayRequest( - req []NilUnixSeconds, +func encodeTestRequestIntegerUnixMilliArrayRequest( + req []time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1144,7 +1144,7 @@ func encodeTestRequestIntegerUnixSecondsNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e, json.EncodeUnixSeconds) + json.EncodeUnixMilli(e, elem) } e.ArrEnd() } @@ -1153,8 +1153,8 @@ func encodeTestRequestIntegerUnixSecondsNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest( - req [][]NilUnixSeconds, +func encodeTestRequestIntegerUnixMilliArrayArrayRequest( + req [][]time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1165,7 +1165,7 @@ func encodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e, json.EncodeUnixSeconds) + json.EncodeUnixMilli(e, elem) } e.ArrEnd() } @@ -1176,8 +1176,8 @@ func encodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNullRequest( - req OptNull, +func encodeTestRequestIntegerUnixMilliNullableRequest( + req OptNilUnixMilli, r *http.Request, ) error { const contentType = "application/json" @@ -1188,15 +1188,15 @@ func encodeTestRequestNullRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e) + req.Encode(e, json.EncodeUnixMilli) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNullArrayRequest( - req []struct{}, +func encodeTestRequestIntegerUnixMilliNullableArrayRequest( + req []NilUnixMilli, r *http.Request, ) error { const contentType = "application/json" @@ -1205,8 +1205,7 @@ func encodeTestRequestNullArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - _ = elem - e.Null() + elem.Encode(e, json.EncodeUnixMilli) } e.ArrEnd() } @@ -1215,8 +1214,8 @@ func encodeTestRequestNullArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNullArrayArrayRequest( - req [][]struct{}, +func encodeTestRequestIntegerUnixMilliNullableArrayArrayRequest( + req [][]NilUnixMilli, r *http.Request, ) error { const contentType = "application/json" @@ -1227,8 +1226,7 @@ func encodeTestRequestNullArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - _ = elem - e.Null() + elem.Encode(e, json.EncodeUnixMilli) } e.ArrEnd() } @@ -1239,8 +1237,8 @@ func encodeTestRequestNullArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNullNullableRequest( - req OptNull, +func encodeTestRequestIntegerUnixNanoRequest( + req OptUnixNano, r *http.Request, ) error { const contentType = "application/json" @@ -1251,15 +1249,15 @@ func encodeTestRequestNullNullableRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e) + req.Encode(e, json.EncodeUnixNano) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNullNullableArrayRequest( - req []struct{}, +func encodeTestRequestIntegerUnixNanoArrayRequest( + req []time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1268,8 +1266,7 @@ func encodeTestRequestNullNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - _ = elem - e.Null() + json.EncodeUnixNano(e, elem) } e.ArrEnd() } @@ -1278,8 +1275,8 @@ func encodeTestRequestNullNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNullNullableArrayArrayRequest( - req [][]struct{}, +func encodeTestRequestIntegerUnixNanoArrayArrayRequest( + req [][]time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1290,8 +1287,7 @@ func encodeTestRequestNullNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - _ = elem - e.Null() + json.EncodeUnixNano(e, elem) } e.ArrEnd() } @@ -1302,8 +1298,8 @@ func encodeTestRequestNullNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberRequest( - req OptFloat64, +func encodeTestRequestIntegerUnixNanoNullableRequest( + req OptNilUnixNano, r *http.Request, ) error { const contentType = "application/json" @@ -1314,15 +1310,15 @@ func encodeTestRequestNumberRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e) + req.Encode(e, json.EncodeUnixNano) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberArrayRequest( - req []float64, +func encodeTestRequestIntegerUnixNanoNullableArrayRequest( + req []NilUnixNano, r *http.Request, ) error { const contentType = "application/json" @@ -1331,7 +1327,7 @@ func encodeTestRequestNumberArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - e.Float64(elem) + elem.Encode(e, json.EncodeUnixNano) } e.ArrEnd() } @@ -1340,8 +1336,8 @@ func encodeTestRequestNumberArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberArrayArrayRequest( - req [][]float64, +func encodeTestRequestIntegerUnixNanoNullableArrayArrayRequest( + req [][]NilUnixNano, r *http.Request, ) error { const contentType = "application/json" @@ -1352,7 +1348,7 @@ func encodeTestRequestNumberArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Float64(elem) + elem.Encode(e, json.EncodeUnixNano) } e.ArrEnd() } @@ -1363,8 +1359,8 @@ func encodeTestRequestNumberArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberDoubleRequest( - req OptFloat64, +func encodeTestRequestIntegerUnixNullableRequest( + req OptNilUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -1375,15 +1371,15 @@ func encodeTestRequestNumberDoubleRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e) + req.Encode(e, json.EncodeUnixSeconds) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberDoubleArrayRequest( - req []float64, +func encodeTestRequestIntegerUnixNullableArrayRequest( + req []NilUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -1392,7 +1388,7 @@ func encodeTestRequestNumberDoubleArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - e.Float64(elem) + elem.Encode(e, json.EncodeUnixSeconds) } e.ArrEnd() } @@ -1401,8 +1397,8 @@ func encodeTestRequestNumberDoubleArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberDoubleArrayArrayRequest( - req [][]float64, +func encodeTestRequestIntegerUnixNullableArrayArrayRequest( + req [][]NilUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -1413,7 +1409,7 @@ func encodeTestRequestNumberDoubleArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Float64(elem) + elem.Encode(e, json.EncodeUnixSeconds) } e.ArrEnd() } @@ -1424,8 +1420,8 @@ func encodeTestRequestNumberDoubleArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberDoubleNullableRequest( - req OptNilFloat64, +func encodeTestRequestIntegerUnixSecondsRequest( + req OptUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -1436,15 +1432,15 @@ func encodeTestRequestNumberDoubleNullableRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e) + req.Encode(e, json.EncodeUnixSeconds) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberDoubleNullableArrayRequest( - req []NilFloat64, +func encodeTestRequestIntegerUnixSecondsArrayRequest( + req []time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1453,7 +1449,7 @@ func encodeTestRequestNumberDoubleNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e) + json.EncodeUnixSeconds(e, elem) } e.ArrEnd() } @@ -1462,8 +1458,8 @@ func encodeTestRequestNumberDoubleNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberDoubleNullableArrayArrayRequest( - req [][]NilFloat64, +func encodeTestRequestIntegerUnixSecondsArrayArrayRequest( + req [][]time.Time, r *http.Request, ) error { const contentType = "application/json" @@ -1474,7 +1470,7 @@ func encodeTestRequestNumberDoubleNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e) + json.EncodeUnixSeconds(e, elem) } e.ArrEnd() } @@ -1485,8 +1481,8 @@ func encodeTestRequestNumberDoubleNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberFloatRequest( - req OptFloat32, +func encodeTestRequestIntegerUnixSecondsNullableRequest( + req OptNilUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -1497,15 +1493,15 @@ func encodeTestRequestNumberFloatRequest( e := jx.GetEncoder() { if req.Set { - req.Encode(e) + req.Encode(e, json.EncodeUnixSeconds) } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberFloatArrayRequest( - req []float32, +func encodeTestRequestIntegerUnixSecondsNullableArrayRequest( + req []NilUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -1514,7 +1510,7 @@ func encodeTestRequestNumberFloatArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - e.Float32(elem) + elem.Encode(e, json.EncodeUnixSeconds) } e.ArrEnd() } @@ -1523,8 +1519,8 @@ func encodeTestRequestNumberFloatArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberFloatArrayArrayRequest( - req [][]float32, +func encodeTestRequestIntegerUnixSecondsNullableArrayArrayRequest( + req [][]NilUnixSeconds, r *http.Request, ) error { const contentType = "application/json" @@ -1535,7 +1531,7 @@ func encodeTestRequestNumberFloatArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Float32(elem) + elem.Encode(e, json.EncodeUnixSeconds) } e.ArrEnd() } @@ -1546,8 +1542,8 @@ func encodeTestRequestNumberFloatArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberFloatNullableRequest( - req OptNilFloat32, +func encodeTestRequestNullRequest( + req OptNull, r *http.Request, ) error { const contentType = "application/json" @@ -1565,8 +1561,8 @@ func encodeTestRequestNumberFloatNullableRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberFloatNullableArrayRequest( - req []NilFloat32, +func encodeTestRequestNullArrayRequest( + req []struct{}, r *http.Request, ) error { const contentType = "application/json" @@ -1575,7 +1571,8 @@ func encodeTestRequestNumberFloatNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e) + _ = elem + e.Null() } e.ArrEnd() } @@ -1584,8 +1581,8 @@ func encodeTestRequestNumberFloatNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberFloatNullableArrayArrayRequest( - req [][]NilFloat32, +func encodeTestRequestNullArrayArrayRequest( + req [][]struct{}, r *http.Request, ) error { const contentType = "application/json" @@ -1596,7 +1593,8 @@ func encodeTestRequestNumberFloatNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e) + _ = elem + e.Null() } e.ArrEnd() } @@ -1607,8 +1605,8 @@ func encodeTestRequestNumberFloatNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt32Request( - req OptInt32, +func encodeTestRequestNullNullableRequest( + req OptNull, r *http.Request, ) error { const contentType = "application/json" @@ -1626,8 +1624,8 @@ func encodeTestRequestNumberInt32Request( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt32ArrayRequest( - req []int32, +func encodeTestRequestNullNullableArrayRequest( + req []struct{}, r *http.Request, ) error { const contentType = "application/json" @@ -1636,7 +1634,8 @@ func encodeTestRequestNumberInt32ArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - e.Int32(elem) + _ = elem + e.Null() } e.ArrEnd() } @@ -1645,8 +1644,8 @@ func encodeTestRequestNumberInt32ArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt32ArrayArrayRequest( - req [][]int32, +func encodeTestRequestNullNullableArrayArrayRequest( + req [][]struct{}, r *http.Request, ) error { const contentType = "application/json" @@ -1657,7 +1656,8 @@ func encodeTestRequestNumberInt32ArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Int32(elem) + _ = elem + e.Null() } e.ArrEnd() } @@ -1668,8 +1668,8 @@ func encodeTestRequestNumberInt32ArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt32NullableRequest( - req OptNilInt32, +func encodeTestRequestNumberRequest( + req OptFloat64, r *http.Request, ) error { const contentType = "application/json" @@ -1687,8 +1687,8 @@ func encodeTestRequestNumberInt32NullableRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt32NullableArrayRequest( - req []NilInt32, +func encodeTestRequestNumberArrayRequest( + req []float64, r *http.Request, ) error { const contentType = "application/json" @@ -1697,7 +1697,7 @@ func encodeTestRequestNumberInt32NullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e) + e.Float64(elem) } e.ArrEnd() } @@ -1706,8 +1706,8 @@ func encodeTestRequestNumberInt32NullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt32NullableArrayArrayRequest( - req [][]NilInt32, +func encodeTestRequestNumberArrayArrayRequest( + req [][]float64, r *http.Request, ) error { const contentType = "application/json" @@ -1718,7 +1718,7 @@ func encodeTestRequestNumberInt32NullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e) + e.Float64(elem) } e.ArrEnd() } @@ -1729,8 +1729,8 @@ func encodeTestRequestNumberInt32NullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt64Request( - req OptInt64, +func encodeTestRequestNumberDoubleRequest( + req OptFloat64, r *http.Request, ) error { const contentType = "application/json" @@ -1748,8 +1748,8 @@ func encodeTestRequestNumberInt64Request( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt64ArrayRequest( - req []int64, +func encodeTestRequestNumberDoubleArrayRequest( + req []float64, r *http.Request, ) error { const contentType = "application/json" @@ -1758,7 +1758,7 @@ func encodeTestRequestNumberInt64ArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - e.Int64(elem) + e.Float64(elem) } e.ArrEnd() } @@ -1767,8 +1767,8 @@ func encodeTestRequestNumberInt64ArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt64ArrayArrayRequest( - req [][]int64, +func encodeTestRequestNumberDoubleArrayArrayRequest( + req [][]float64, r *http.Request, ) error { const contentType = "application/json" @@ -1779,7 +1779,7 @@ func encodeTestRequestNumberInt64ArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Int64(elem) + e.Float64(elem) } e.ArrEnd() } @@ -1790,8 +1790,8 @@ func encodeTestRequestNumberInt64ArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt64NullableRequest( - req OptNilInt64, +func encodeTestRequestNumberDoubleNullableRequest( + req OptNilFloat64, r *http.Request, ) error { const contentType = "application/json" @@ -1809,8 +1809,8 @@ func encodeTestRequestNumberInt64NullableRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt64NullableArrayRequest( - req []NilInt64, +func encodeTestRequestNumberDoubleNullableArrayRequest( + req []NilFloat64, r *http.Request, ) error { const contentType = "application/json" @@ -1828,8 +1828,8 @@ func encodeTestRequestNumberInt64NullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberInt64NullableArrayArrayRequest( - req [][]NilInt64, +func encodeTestRequestNumberDoubleNullableArrayArrayRequest( + req [][]NilFloat64, r *http.Request, ) error { const contentType = "application/json" @@ -1851,8 +1851,8 @@ func encodeTestRequestNumberInt64NullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberNullableRequest( - req OptNilFloat64, +func encodeTestRequestNumberFloatRequest( + req OptFloat32, r *http.Request, ) error { const contentType = "application/json" @@ -1870,8 +1870,8 @@ func encodeTestRequestNumberNullableRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberNullableArrayRequest( - req []NilFloat64, +func encodeTestRequestNumberFloatArrayRequest( + req []float32, r *http.Request, ) error { const contentType = "application/json" @@ -1880,7 +1880,7 @@ func encodeTestRequestNumberNullableArrayRequest( if req != nil { e.ArrStart() for _, elem := range req { - elem.Encode(e) + e.Float32(elem) } e.ArrEnd() } @@ -1889,8 +1889,8 @@ func encodeTestRequestNumberNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestNumberNullableArrayArrayRequest( - req [][]NilFloat64, +func encodeTestRequestNumberFloatArrayArrayRequest( + req [][]float32, r *http.Request, ) error { const contentType = "application/json" @@ -1901,7 +1901,7 @@ func encodeTestRequestNumberNullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e) + e.Float32(elem) } e.ArrEnd() } @@ -1912,172 +1912,640 @@ func encodeTestRequestNumberNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredAnyRequest( - req jx.Raw, +func encodeTestRequestNumberFloatNullableRequest( + req OptNilFloat32, r *http.Request, ) error { const contentType = "application/json" - e := jx.GetEncoder() - { - if len(req) != 0 { - e.Raw(req) - } + if !req.Set { + // Keep request with empty body if value is not set. + return nil } - encoded := e.Bytes() - ht.SetBody(r, bytes.NewReader(encoded), contentType) - return nil -} -func encodeTestRequestRequiredBooleanRequest( - req bool, - r *http.Request, -) error { - const contentType = "application/json" e := jx.GetEncoder() { - e.Bool(req) + if req.Set { + req.Encode(e) + } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredBooleanArrayRequest( - req []bool, +func encodeTestRequestNumberFloatNullableArrayRequest( + req []NilFloat32, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - e.ArrStart() - for _, elem := range req { - e.Bool(elem) + if req != nil { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() } - e.ArrEnd() } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredBooleanArrayArrayRequest( - req [][]bool, +func encodeTestRequestNumberFloatNullableArrayArrayRequest( + req [][]NilFloat32, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - e.ArrStart() - for _, elem := range req { + if req != nil { e.ArrStart() - for _, elem := range elem { - e.Bool(elem) + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() } e.ArrEnd() } - e.ArrEnd() } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredBooleanNullableRequest( - req NilBool, +func encodeTestRequestNumberInt32Request( + req OptInt32, r *http.Request, ) error { const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } e := jx.GetEncoder() { - req.Encode(e) + if req.Set { + req.Encode(e) + } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredBooleanNullableArrayRequest( - req []NilBool, +func encodeTestRequestNumberInt32ArrayRequest( + req []int32, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - e.ArrStart() - for _, elem := range req { - elem.Encode(e) + if req != nil { + e.ArrStart() + for _, elem := range req { + e.Int32(elem) + } + e.ArrEnd() } - e.ArrEnd() } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredBooleanNullableArrayArrayRequest( - req [][]NilBool, +func encodeTestRequestNumberInt32ArrayArrayRequest( + req [][]int32, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - e.ArrStart() - for _, elem := range req { + if req != nil { e.ArrStart() - for _, elem := range elem { - elem.Encode(e) + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + e.Int32(elem) + } + e.ArrEnd() } e.ArrEnd() } - e.ArrEnd() } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredEmptyStructRequest( - req TestRequestRequiredEmptyStructReq, +func encodeTestRequestNumberInt32NullableRequest( + req OptNilInt32, r *http.Request, ) error { const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } e := jx.GetEncoder() { - req.Encode(e) + if req.Set { + req.Encode(e) + } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredFormatTestRequest( - req TestRequestRequiredFormatTestReq, +func encodeTestRequestNumberInt32NullableArrayRequest( + req []NilInt32, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - req.Encode(e) + if req != nil { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() + } } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerRequest( - req int, +func encodeTestRequestNumberInt32NullableArrayArrayRequest( + req [][]NilInt32, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - e.Int(req) - } - encoded := e.Bytes() - ht.SetBody(r, bytes.NewReader(encoded), contentType) - return nil -} -func encodeTestRequestRequiredIntegerArrayRequest( - req []int, - r *http.Request, + if req != nil { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberInt64Request( + req OptInt64, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := jx.GetEncoder() + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberInt64ArrayRequest( + req []int64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + if req != nil { + e.ArrStart() + for _, elem := range req { + e.Int64(elem) + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberInt64ArrayArrayRequest( + req [][]int64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + if req != nil { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + e.Int64(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberInt64NullableRequest( + req OptNilInt64, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := jx.GetEncoder() + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberInt64NullableArrayRequest( + req []NilInt64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + if req != nil { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberInt64NullableArrayArrayRequest( + req [][]NilInt64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + if req != nil { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberNullableRequest( + req OptNilFloat64, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := jx.GetEncoder() + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberNullableArrayRequest( + req []NilFloat64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + if req != nil { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestNumberNullableArrayArrayRequest( + req [][]NilFloat64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + if req != nil { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredAnyRequest( + req jx.Raw, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + if len(req) != 0 { + e.Raw(req) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredBooleanRequest( + req bool, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Bool(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredBooleanArrayRequest( + req []bool, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.Bool(elem) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredBooleanArrayArrayRequest( + req [][]bool, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + e.Bool(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredBooleanNullableRequest( + req NilBool, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredBooleanNullableArrayRequest( + req []NilBool, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredBooleanNullableArrayArrayRequest( + req [][]NilBool, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredEmptyStructRequest( + req TestRequestRequiredEmptyStructReq, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredFormatTestRequest( + req TestRequestRequiredFormatTestReq, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerRequest( + req int, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Int(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerArrayRequest( + req []int, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.Int(elem) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerArrayArrayRequest( + req [][]int, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + e.Int(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerInt32Request( + req int32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Int32(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerInt32ArrayRequest( + req []int32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.Int32(elem) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerInt32ArrayArrayRequest( + req [][]int32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + e.Int32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerInt32NullableRequest( + req NilInt32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerInt32NullableArrayRequest( + req []NilInt32, + r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { e.ArrStart() for _, elem := range req { - e.Int(elem) + elem.Encode(e) } e.ArrEnd() } @@ -2085,8 +2553,8 @@ func encodeTestRequestRequiredIntegerArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerArrayArrayRequest( - req [][]int, +func encodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest( + req [][]NilInt32, r *http.Request, ) error { const contentType = "application/json" @@ -2096,7 +2564,7 @@ func encodeTestRequestRequiredIntegerArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Int(elem) + elem.Encode(e) } e.ArrEnd() } @@ -2106,21 +2574,21 @@ func encodeTestRequestRequiredIntegerArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt32Request( - req int32, +func encodeTestRequestRequiredIntegerInt64Request( + req int64, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - e.Int32(req) + e.Int64(req) } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt32ArrayRequest( - req []int32, +func encodeTestRequestRequiredIntegerInt64ArrayRequest( + req []int64, r *http.Request, ) error { const contentType = "application/json" @@ -2128,7 +2596,7 @@ func encodeTestRequestRequiredIntegerInt32ArrayRequest( { e.ArrStart() for _, elem := range req { - e.Int32(elem) + e.Int64(elem) } e.ArrEnd() } @@ -2136,8 +2604,8 @@ func encodeTestRequestRequiredIntegerInt32ArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt32ArrayArrayRequest( - req [][]int32, +func encodeTestRequestRequiredIntegerInt64ArrayArrayRequest( + req [][]int64, r *http.Request, ) error { const contentType = "application/json" @@ -2147,7 +2615,7 @@ func encodeTestRequestRequiredIntegerInt32ArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Int32(elem) + e.Int64(elem) } e.ArrEnd() } @@ -2157,8 +2625,8 @@ func encodeTestRequestRequiredIntegerInt32ArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt32NullableRequest( - req NilInt32, +func encodeTestRequestRequiredIntegerInt64NullableRequest( + req NilInt64, r *http.Request, ) error { const contentType = "application/json" @@ -2170,8 +2638,174 @@ func encodeTestRequestRequiredIntegerInt32NullableRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt32NullableArrayRequest( - req []NilInt32, +func encodeTestRequestRequiredIntegerInt64NullableArrayRequest( + req []NilInt64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest( + req [][]NilInt64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerNullableRequest( + req NilInt, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerNullableArrayRequest( + req []NilInt, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerNullableArrayArrayRequest( + req [][]NilInt, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUintRequest( + req uint, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.UInt(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint32Request( + req uint32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.UInt32(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint32ArrayRequest( + req []uint32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.UInt32(elem) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint32ArrayArrayRequest( + req [][]uint32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + e.UInt32(elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint32NullableRequest( + req NilUint32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint32NullableArrayRequest( + req []NilUint32, r *http.Request, ) error { const contentType = "application/json" @@ -2187,8 +2821,59 @@ func encodeTestRequestRequiredIntegerInt32NullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest( - req [][]NilInt32, +func encodeTestRequestRequiredIntegerUint32NullableArrayArrayRequest( + req [][]NilUint32, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint64Request( + req uint64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.UInt64(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint64ArrayRequest( + req []uint64, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.ArrStart() + for _, elem := range req { + e.UInt64(elem) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestRequestRequiredIntegerUint64ArrayArrayRequest( + req [][]uint64, r *http.Request, ) error { const contentType = "application/json" @@ -2198,7 +2883,7 @@ func encodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e) + e.UInt64(elem) } e.ArrEnd() } @@ -2208,21 +2893,21 @@ func encodeTestRequestRequiredIntegerInt32NullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt64Request( - req int64, +func encodeTestRequestRequiredIntegerUint64NullableRequest( + req NilUint64, r *http.Request, ) error { const contentType = "application/json" e := jx.GetEncoder() { - e.Int64(req) + req.Encode(e) } encoded := e.Bytes() ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt64ArrayRequest( - req []int64, +func encodeTestRequestRequiredIntegerUint64NullableArrayRequest( + req []NilUint64, r *http.Request, ) error { const contentType = "application/json" @@ -2230,7 +2915,7 @@ func encodeTestRequestRequiredIntegerInt64ArrayRequest( { e.ArrStart() for _, elem := range req { - e.Int64(elem) + elem.Encode(e) } e.ArrEnd() } @@ -2238,8 +2923,8 @@ func encodeTestRequestRequiredIntegerInt64ArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt64ArrayArrayRequest( - req [][]int64, +func encodeTestRequestRequiredIntegerUint64NullableArrayArrayRequest( + req [][]NilUint64, r *http.Request, ) error { const contentType = "application/json" @@ -2249,7 +2934,7 @@ func encodeTestRequestRequiredIntegerInt64ArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - e.Int64(elem) + elem.Encode(e) } e.ArrEnd() } @@ -2259,21 +2944,8 @@ func encodeTestRequestRequiredIntegerInt64ArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt64NullableRequest( - req NilInt64, - r *http.Request, -) error { - const contentType = "application/json" - e := jx.GetEncoder() - { - req.Encode(e) - } - encoded := e.Bytes() - ht.SetBody(r, bytes.NewReader(encoded), contentType) - return nil -} -func encodeTestRequestRequiredIntegerInt64NullableArrayRequest( - req []NilInt64, +func encodeTestRequestRequiredIntegerUintArrayRequest( + req []uint, r *http.Request, ) error { const contentType = "application/json" @@ -2281,7 +2953,7 @@ func encodeTestRequestRequiredIntegerInt64NullableArrayRequest( { e.ArrStart() for _, elem := range req { - elem.Encode(e) + e.UInt(elem) } e.ArrEnd() } @@ -2289,8 +2961,8 @@ func encodeTestRequestRequiredIntegerInt64NullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest( - req [][]NilInt64, +func encodeTestRequestRequiredIntegerUintArrayArrayRequest( + req [][]uint, r *http.Request, ) error { const contentType = "application/json" @@ -2300,7 +2972,7 @@ func encodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest( for _, elem := range req { e.ArrStart() for _, elem := range elem { - elem.Encode(e) + e.UInt(elem) } e.ArrEnd() } @@ -2310,8 +2982,8 @@ func encodeTestRequestRequiredIntegerInt64NullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerNullableRequest( - req NilInt, +func encodeTestRequestRequiredIntegerUintNullableRequest( + req NilUint, r *http.Request, ) error { const contentType = "application/json" @@ -2323,8 +2995,8 @@ func encodeTestRequestRequiredIntegerNullableRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerNullableArrayRequest( - req []NilInt, +func encodeTestRequestRequiredIntegerUintNullableArrayRequest( + req []NilUint, r *http.Request, ) error { const contentType = "application/json" @@ -2340,8 +3012,8 @@ func encodeTestRequestRequiredIntegerNullableArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } -func encodeTestRequestRequiredIntegerNullableArrayArrayRequest( - req [][]NilInt, +func encodeTestRequestRequiredIntegerUintNullableArrayArrayRequest( + req [][]NilUint, r *http.Request, ) error { const contentType = "application/json" @@ -8762,6 +9434,240 @@ func encodeTestResponseIntegerNullableArrayArrayRequest( ht.SetBody(r, bytes.NewReader(encoded), contentType) return nil } +func encodeTestResponseIntegerUintRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint32Request( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint32ArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint32ArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint32NullableRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint32NullableArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint32NullableArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint64Request( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint64ArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint64ArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint64NullableRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint64NullableArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUint64NullableArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUintArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUintArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUintNullableRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUintNullableArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} +func encodeTestResponseIntegerUintNullableArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := jx.GetEncoder() + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} func encodeTestResponseIntegerUnixRequest( req string, r *http.Request, diff --git a/examples/ex_test_format/oas_response_decoders_gen.go b/examples/ex_test_format/oas_response_decoders_gen.go index 2a384055c..ead7fd1e0 100644 --- a/examples/ex_test_format/oas_response_decoders_gen.go +++ b/examples/ex_test_format/oas_response_decoders_gen.go @@ -943,7 +943,7 @@ func decodeTestRequestIntegerNullableArrayArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUintResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -976,7 +976,7 @@ func decodeTestRequestIntegerUnixResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint32Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1009,7 +1009,7 @@ func decodeTestRequestIntegerUnixArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1042,7 +1042,7 @@ func decodeTestRequestIntegerUnixArrayArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1075,7 +1075,7 @@ func decodeTestRequestIntegerUnixMicroResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1108,7 +1108,7 @@ func decodeTestRequestIntegerUnixMicroArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1141,7 +1141,7 @@ func decodeTestRequestIntegerUnixMicroArrayArrayResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1174,7 +1174,7 @@ func decodeTestRequestIntegerUnixMicroNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint64Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1207,7 +1207,7 @@ func decodeTestRequestIntegerUnixMicroNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1240,7 +1240,7 @@ func decodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(resp *http.Resp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1273,7 +1273,7 @@ func decodeTestRequestIntegerUnixMilliResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1306,7 +1306,7 @@ func decodeTestRequestIntegerUnixMilliArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1339,7 +1339,7 @@ func decodeTestRequestIntegerUnixMilliArrayArrayResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUint64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1372,7 +1372,7 @@ func decodeTestRequestIntegerUnixMilliNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUintArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1405,7 +1405,7 @@ func decodeTestRequestIntegerUnixMilliNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUintArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1438,7 +1438,7 @@ func decodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(resp *http.Resp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUintNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1471,7 +1471,7 @@ func decodeTestRequestIntegerUnixNanoResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUintNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1504,7 +1504,7 @@ func decodeTestRequestIntegerUnixNanoArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUintNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1537,7 +1537,7 @@ func decodeTestRequestIntegerUnixNanoArrayArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1570,7 +1570,7 @@ func decodeTestRequestIntegerUnixNanoNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1603,7 +1603,7 @@ func decodeTestRequestIntegerUnixNanoNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1636,7 +1636,7 @@ func decodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1669,7 +1669,7 @@ func decodeTestRequestIntegerUnixNullableResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1702,7 +1702,7 @@ func decodeTestRequestIntegerUnixNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1735,7 +1735,7 @@ func decodeTestRequestIntegerUnixNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1768,7 +1768,7 @@ func decodeTestRequestIntegerUnixSecondsResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1801,7 +1801,7 @@ func decodeTestRequestIntegerUnixSecondsArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1834,7 +1834,7 @@ func decodeTestRequestIntegerUnixSecondsArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1867,7 +1867,7 @@ func decodeTestRequestIntegerUnixSecondsNullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1900,7 +1900,7 @@ func decodeTestRequestIntegerUnixSecondsNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1933,7 +1933,7 @@ func decodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNullResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1966,7 +1966,7 @@ func decodeTestRequestNullResponse(resp *http.Response, span trace.Span) (res Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNullArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -1999,7 +1999,7 @@ func decodeTestRequestNullArrayResponse(resp *http.Response, span trace.Span) (r return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNullArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2032,7 +2032,7 @@ func decodeTestRequestNullArrayArrayResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNullNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2065,7 +2065,7 @@ func decodeTestRequestNullNullableResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNullNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2098,7 +2098,7 @@ func decodeTestRequestNullNullableArrayResponse(resp *http.Response, span trace. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNullNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2131,7 +2131,7 @@ func decodeTestRequestNullNullableArrayArrayResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2164,7 +2164,7 @@ func decodeTestRequestNumberResponse(resp *http.Response, span trace.Span) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2197,7 +2197,7 @@ func decodeTestRequestNumberArrayResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2230,7 +2230,7 @@ func decodeTestRequestNumberArrayArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberDoubleResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2263,7 +2263,7 @@ func decodeTestRequestNumberDoubleResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberDoubleArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2296,7 +2296,7 @@ func decodeTestRequestNumberDoubleArrayResponse(resp *http.Response, span trace. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberDoubleArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2329,7 +2329,7 @@ func decodeTestRequestNumberDoubleArrayArrayResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberDoubleNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2362,7 +2362,7 @@ func decodeTestRequestNumberDoubleNullableResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberDoubleNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2395,7 +2395,7 @@ func decodeTestRequestNumberDoubleNullableArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberDoubleNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2428,7 +2428,7 @@ func decodeTestRequestNumberDoubleNullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberFloatResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2461,7 +2461,7 @@ func decodeTestRequestNumberFloatResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberFloatArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2494,7 +2494,7 @@ func decodeTestRequestNumberFloatArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberFloatArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2527,7 +2527,7 @@ func decodeTestRequestNumberFloatArrayArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberFloatNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNullResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2560,7 +2560,7 @@ func decodeTestRequestNumberFloatNullableResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberFloatNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNullArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2593,7 +2593,7 @@ func decodeTestRequestNumberFloatNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberFloatNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNullArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2626,7 +2626,7 @@ func decodeTestRequestNumberFloatNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNullNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2659,7 +2659,7 @@ func decodeTestRequestNumberInt32Response(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNullNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2692,7 +2692,7 @@ func decodeTestRequestNumberInt32ArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNullNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2725,7 +2725,7 @@ func decodeTestRequestNumberInt32ArrayArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2758,7 +2758,7 @@ func decodeTestRequestNumberInt32NullableResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2791,7 +2791,7 @@ func decodeTestRequestNumberInt32NullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2824,7 +2824,7 @@ func decodeTestRequestNumberInt32NullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberDoubleResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2857,7 +2857,7 @@ func decodeTestRequestNumberInt64Response(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberDoubleArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2890,7 +2890,7 @@ func decodeTestRequestNumberInt64ArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberDoubleArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2923,7 +2923,7 @@ func decodeTestRequestNumberInt64ArrayArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberDoubleNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2956,7 +2956,7 @@ func decodeTestRequestNumberInt64NullableResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberDoubleNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -2989,7 +2989,7 @@ func decodeTestRequestNumberInt64NullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberDoubleNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3022,7 +3022,7 @@ func decodeTestRequestNumberInt64NullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberFloatResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3055,7 +3055,7 @@ func decodeTestRequestNumberNullableResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberFloatArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3088,7 +3088,7 @@ func decodeTestRequestNumberNullableArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestNumberNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberFloatArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3121,7 +3121,7 @@ func decodeTestRequestNumberNullableArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredAnyResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberFloatNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3154,7 +3154,7 @@ func decodeTestRequestRequiredAnyResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredBooleanResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberFloatNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3187,7 +3187,7 @@ func decodeTestRequestRequiredBooleanResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredBooleanArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberFloatNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3220,7 +3220,7 @@ func decodeTestRequestRequiredBooleanArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredBooleanArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3253,7 +3253,7 @@ func decodeTestRequestRequiredBooleanArrayArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredBooleanNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3286,7 +3286,7 @@ func decodeTestRequestRequiredBooleanNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredBooleanNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3319,7 +3319,7 @@ func decodeTestRequestRequiredBooleanNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredBooleanNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3352,7 +3352,7 @@ func decodeTestRequestRequiredBooleanNullableArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredEmptyStructResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3385,7 +3385,7 @@ func decodeTestRequestRequiredEmptyStructResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredFormatTestResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3418,7 +3418,7 @@ func decodeTestRequestRequiredFormatTestResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3451,7 +3451,7 @@ func decodeTestRequestRequiredIntegerResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3484,7 +3484,7 @@ func decodeTestRequestRequiredIntegerArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3517,7 +3517,7 @@ func decodeTestRequestRequiredIntegerArrayArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3550,7 +3550,7 @@ func decodeTestRequestRequiredIntegerInt32Response(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3583,7 +3583,7 @@ func decodeTestRequestRequiredIntegerInt32ArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3616,7 +3616,7 @@ func decodeTestRequestRequiredIntegerInt32ArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3649,7 +3649,7 @@ func decodeTestRequestRequiredIntegerInt32NullableResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3682,7 +3682,7 @@ func decodeTestRequestRequiredIntegerInt32NullableArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestNumberNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3715,7 +3715,7 @@ func decodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredAnyResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3748,7 +3748,7 @@ func decodeTestRequestRequiredIntegerInt64Response(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredBooleanResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3781,7 +3781,7 @@ func decodeTestRequestRequiredIntegerInt64ArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredBooleanArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3814,7 +3814,7 @@ func decodeTestRequestRequiredIntegerInt64ArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredBooleanArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3847,7 +3847,7 @@ func decodeTestRequestRequiredIntegerInt64NullableResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredBooleanNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3880,7 +3880,7 @@ func decodeTestRequestRequiredIntegerInt64NullableArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredBooleanNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3913,7 +3913,7 @@ func decodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredBooleanNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3946,7 +3946,7 @@ func decodeTestRequestRequiredIntegerNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredEmptyStructResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -3979,7 +3979,7 @@ func decodeTestRequestRequiredIntegerNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredFormatTestResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4012,7 +4012,7 @@ func decodeTestRequestRequiredIntegerNullableArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4045,7 +4045,7 @@ func decodeTestRequestRequiredIntegerUnixResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4078,7 +4078,7 @@ func decodeTestRequestRequiredIntegerUnixArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4111,7 +4111,7 @@ func decodeTestRequestRequiredIntegerUnixArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4144,7 +4144,7 @@ func decodeTestRequestRequiredIntegerUnixMicroResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4177,7 +4177,7 @@ func decodeTestRequestRequiredIntegerUnixMicroArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4210,7 +4210,7 @@ func decodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(resp *http.Resp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4243,7 +4243,7 @@ func decodeTestRequestRequiredIntegerUnixMicroNullableResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4276,7 +4276,7 @@ func decodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4309,7 +4309,7 @@ func decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(resp *h return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4342,7 +4342,7 @@ func decodeTestRequestRequiredIntegerUnixMilliResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4375,7 +4375,7 @@ func decodeTestRequestRequiredIntegerUnixMilliArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4408,7 +4408,7 @@ func decodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(resp *http.Resp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4441,7 +4441,7 @@ func decodeTestRequestRequiredIntegerUnixMilliNullableResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4474,7 +4474,7 @@ func decodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4507,7 +4507,7 @@ func decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(resp *h return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4540,7 +4540,7 @@ func decodeTestRequestRequiredIntegerUnixNanoResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4573,7 +4573,7 @@ func decodeTestRequestRequiredIntegerUnixNanoArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4606,7 +4606,7 @@ func decodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUintResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4639,7 +4639,7 @@ func decodeTestRequestRequiredIntegerUnixNanoNullableResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint32Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4672,7 +4672,7 @@ func decodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4705,7 +4705,7 @@ func decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(resp *ht return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4738,7 +4738,7 @@ func decodeTestRequestRequiredIntegerUnixNullableResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4771,7 +4771,7 @@ func decodeTestRequestRequiredIntegerUnixNullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4804,7 +4804,7 @@ func decodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4837,7 +4837,7 @@ func decodeTestRequestRequiredIntegerUnixSecondsResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint64Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4870,7 +4870,7 @@ func decodeTestRequestRequiredIntegerUnixSecondsArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4903,7 +4903,7 @@ func decodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4936,7 +4936,7 @@ func decodeTestRequestRequiredIntegerUnixSecondsNullableResponse(resp *http.Resp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -4969,7 +4969,7 @@ func decodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(resp *http return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5002,7 +5002,7 @@ func decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(resp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNullResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUint64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5035,7 +5035,7 @@ func decodeTestRequestRequiredNullResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNullArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUintArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5068,7 +5068,7 @@ func decodeTestRequestRequiredNullArrayResponse(resp *http.Response, span trace. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNullArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUintArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5101,7 +5101,7 @@ func decodeTestRequestRequiredNullArrayArrayResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNullNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUintNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5134,7 +5134,7 @@ func decodeTestRequestRequiredNullNullableResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNullNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUintNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5167,7 +5167,7 @@ func decodeTestRequestRequiredNullNullableArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNullNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUintNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5200,7 +5200,7 @@ func decodeTestRequestRequiredNullNullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5233,7 +5233,7 @@ func decodeTestRequestRequiredNumberResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5266,7 +5266,7 @@ func decodeTestRequestRequiredNumberArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5299,7 +5299,7 @@ func decodeTestRequestRequiredNumberArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberDoubleResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5332,7 +5332,7 @@ func decodeTestRequestRequiredNumberDoubleResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberDoubleArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5365,7 +5365,7 @@ func decodeTestRequestRequiredNumberDoubleArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberDoubleArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5398,7 +5398,7 @@ func decodeTestRequestRequiredNumberDoubleArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberDoubleNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5431,7 +5431,7 @@ func decodeTestRequestRequiredNumberDoubleNullableResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberDoubleNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5464,7 +5464,7 @@ func decodeTestRequestRequiredNumberDoubleNullableArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5497,7 +5497,7 @@ func decodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberFloatResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5530,7 +5530,7 @@ func decodeTestRequestRequiredNumberFloatResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberFloatArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5563,7 +5563,7 @@ func decodeTestRequestRequiredNumberFloatArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberFloatArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5596,7 +5596,7 @@ func decodeTestRequestRequiredNumberFloatArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberFloatNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5629,7 +5629,7 @@ func decodeTestRequestRequiredNumberFloatNullableResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberFloatNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5662,7 +5662,7 @@ func decodeTestRequestRequiredNumberFloatNullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5695,7 +5695,7 @@ func decodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5728,7 +5728,7 @@ func decodeTestRequestRequiredNumberInt32Response(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5761,7 +5761,7 @@ func decodeTestRequestRequiredNumberInt32ArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5794,7 +5794,7 @@ func decodeTestRequestRequiredNumberInt32ArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5827,7 +5827,7 @@ func decodeTestRequestRequiredNumberInt32NullableResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5860,7 +5860,7 @@ func decodeTestRequestRequiredNumberInt32NullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5893,7 +5893,7 @@ func decodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5926,7 +5926,7 @@ func decodeTestRequestRequiredNumberInt64Response(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5959,7 +5959,7 @@ func decodeTestRequestRequiredNumberInt64ArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -5992,7 +5992,7 @@ func decodeTestRequestRequiredNumberInt64ArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6025,7 +6025,7 @@ func decodeTestRequestRequiredNumberInt64NullableResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6058,7 +6058,7 @@ func decodeTestRequestRequiredNumberInt64NullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6091,7 +6091,7 @@ func decodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6124,7 +6124,7 @@ func decodeTestRequestRequiredNumberNullableResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6157,7 +6157,7 @@ func decodeTestRequestRequiredNumberNullableArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredNumberNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6190,7 +6190,7 @@ func decodeTestRequestRequiredNumberNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNullResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6223,7 +6223,7 @@ func decodeTestRequestRequiredStringResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNullArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6256,7 +6256,7 @@ func decodeTestRequestRequiredStringArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNullArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6289,7 +6289,7 @@ func decodeTestRequestRequiredStringArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringBinaryResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNullNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6322,7 +6322,7 @@ func decodeTestRequestRequiredStringBinaryResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringBinaryArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNullNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6355,7 +6355,7 @@ func decodeTestRequestRequiredStringBinaryArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringBinaryArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNullNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6388,7 +6388,7 @@ func decodeTestRequestRequiredStringBinaryArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringBinaryNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6421,7 +6421,7 @@ func decodeTestRequestRequiredStringBinaryNullableResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringBinaryNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6454,7 +6454,7 @@ func decodeTestRequestRequiredStringBinaryNullableArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6487,7 +6487,7 @@ func decodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringByteResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberDoubleResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6520,7 +6520,7 @@ func decodeTestRequestRequiredStringByteResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringByteArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberDoubleArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6553,7 +6553,7 @@ func decodeTestRequestRequiredStringByteArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringByteArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberDoubleArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6586,7 +6586,7 @@ func decodeTestRequestRequiredStringByteArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringByteNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberDoubleNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6619,7 +6619,7 @@ func decodeTestRequestRequiredStringByteNullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringByteNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberDoubleNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6652,7 +6652,7 @@ func decodeTestRequestRequiredStringByteNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringByteNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6685,7 +6685,7 @@ func decodeTestRequestRequiredStringByteNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberFloatResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6718,7 +6718,7 @@ func decodeTestRequestRequiredStringDateResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberFloatArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6751,7 +6751,7 @@ func decodeTestRequestRequiredStringDateArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberFloatArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6784,7 +6784,7 @@ func decodeTestRequestRequiredStringDateArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberFloatNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6817,7 +6817,7 @@ func decodeTestRequestRequiredStringDateNullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberFloatNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6850,7 +6850,7 @@ func decodeTestRequestRequiredStringDateNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6883,7 +6883,7 @@ func decodeTestRequestRequiredStringDateNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6916,7 +6916,7 @@ func decodeTestRequestRequiredStringDateTimeResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6949,7 +6949,7 @@ func decodeTestRequestRequiredStringDateTimeArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -6982,7 +6982,7 @@ func decodeTestRequestRequiredStringDateTimeArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7015,7 +7015,7 @@ func decodeTestRequestRequiredStringDateTimeNullableResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7048,7 +7048,7 @@ func decodeTestRequestRequiredStringDateTimeNullableArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7081,7 +7081,7 @@ func decodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(resp *htt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDurationResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7114,7 +7114,7 @@ func decodeTestRequestRequiredStringDurationResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDurationArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7147,7 +7147,7 @@ func decodeTestRequestRequiredStringDurationArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDurationArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7180,7 +7180,7 @@ func decodeTestRequestRequiredStringDurationArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDurationNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7213,7 +7213,7 @@ func decodeTestRequestRequiredStringDurationNullableResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDurationNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7246,7 +7246,7 @@ func decodeTestRequestRequiredStringDurationNullableArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringDurationNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7279,7 +7279,7 @@ func decodeTestRequestRequiredStringDurationNullableArrayArrayResponse(resp *htt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringEmailResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7312,7 +7312,7 @@ func decodeTestRequestRequiredStringEmailResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringEmailArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7345,7 +7345,7 @@ func decodeTestRequestRequiredStringEmailArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringEmailArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredNumberNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7378,7 +7378,7 @@ func decodeTestRequestRequiredStringEmailArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringEmailNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7411,7 +7411,7 @@ func decodeTestRequestRequiredStringEmailNullableResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringEmailNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7444,7 +7444,7 @@ func decodeTestRequestRequiredStringEmailNullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringEmailNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7477,7 +7477,7 @@ func decodeTestRequestRequiredStringEmailNullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringHostnameResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringBinaryResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7510,7 +7510,7 @@ func decodeTestRequestRequiredStringHostnameResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringHostnameArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringBinaryArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7543,7 +7543,7 @@ func decodeTestRequestRequiredStringHostnameArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringHostnameArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringBinaryArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7576,7 +7576,7 @@ func decodeTestRequestRequiredStringHostnameArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringHostnameNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringBinaryNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7609,7 +7609,7 @@ func decodeTestRequestRequiredStringHostnameNullableResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringHostnameNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringBinaryNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7642,7 +7642,7 @@ func decodeTestRequestRequiredStringHostnameNullableArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7675,7 +7675,7 @@ func decodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(resp *htt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIPResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringByteResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7708,7 +7708,7 @@ func decodeTestRequestRequiredStringIPResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIPArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringByteArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7741,7 +7741,7 @@ func decodeTestRequestRequiredStringIPArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIPArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringByteArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7774,7 +7774,7 @@ func decodeTestRequestRequiredStringIPArrayArrayResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIPNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringByteNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7807,7 +7807,7 @@ func decodeTestRequestRequiredStringIPNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIPNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringByteNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7840,7 +7840,7 @@ func decodeTestRequestRequiredStringIPNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIPNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringByteNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7873,7 +7873,7 @@ func decodeTestRequestRequiredStringIPNullableArrayArrayResponse(resp *http.Resp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7906,7 +7906,7 @@ func decodeTestRequestRequiredStringInt32Response(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7939,7 +7939,7 @@ func decodeTestRequestRequiredStringInt32ArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -7972,7 +7972,7 @@ func decodeTestRequestRequiredStringInt32ArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8005,7 +8005,7 @@ func decodeTestRequestRequiredStringInt32NullableResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8038,7 +8038,7 @@ func decodeTestRequestRequiredStringInt32NullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8071,7 +8071,7 @@ func decodeTestRequestRequiredStringInt32NullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8104,7 +8104,7 @@ func decodeTestRequestRequiredStringInt64Response(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8137,7 +8137,7 @@ func decodeTestRequestRequiredStringInt64ArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8170,7 +8170,7 @@ func decodeTestRequestRequiredStringInt64ArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8203,7 +8203,7 @@ func decodeTestRequestRequiredStringInt64NullableResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8236,7 +8236,7 @@ func decodeTestRequestRequiredStringInt64NullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8269,7 +8269,7 @@ func decodeTestRequestRequiredStringInt64NullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv4Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDurationResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8302,7 +8302,7 @@ func decodeTestRequestRequiredStringIpv4Response(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv4ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDurationArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8335,7 +8335,7 @@ func decodeTestRequestRequiredStringIpv4ArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv4ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDurationArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8368,7 +8368,7 @@ func decodeTestRequestRequiredStringIpv4ArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv4NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDurationNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8401,7 +8401,7 @@ func decodeTestRequestRequiredStringIpv4NullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv4NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDurationNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8434,7 +8434,7 @@ func decodeTestRequestRequiredStringIpv4NullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringDurationNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8467,7 +8467,7 @@ func decodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv6Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringEmailResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8500,7 +8500,7 @@ func decodeTestRequestRequiredStringIpv6Response(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv6ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringEmailArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8533,7 +8533,7 @@ func decodeTestRequestRequiredStringIpv6ArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv6ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringEmailArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8566,7 +8566,7 @@ func decodeTestRequestRequiredStringIpv6ArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv6NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringEmailNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8599,7 +8599,7 @@ func decodeTestRequestRequiredStringIpv6NullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv6NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringEmailNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8632,7 +8632,7 @@ func decodeTestRequestRequiredStringIpv6NullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringEmailNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8665,7 +8665,7 @@ func decodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringHostnameResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8698,7 +8698,7 @@ func decodeTestRequestRequiredStringNullableResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringHostnameArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8731,7 +8731,7 @@ func decodeTestRequestRequiredStringNullableArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringHostnameArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8764,7 +8764,7 @@ func decodeTestRequestRequiredStringNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringHostnameNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8797,7 +8797,7 @@ func decodeTestRequestRequiredStringPasswordResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringHostnameNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8830,7 +8830,7 @@ func decodeTestRequestRequiredStringPasswordArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8863,7 +8863,7 @@ func decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIPResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8896,7 +8896,7 @@ func decodeTestRequestRequiredStringPasswordNullableResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIPArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8929,7 +8929,7 @@ func decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIPArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8962,7 +8962,7 @@ func decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp *htt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIPNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -8995,7 +8995,7 @@ func decodeTestRequestRequiredStringTimeResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIPNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9028,7 +9028,7 @@ func decodeTestRequestRequiredStringTimeArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIPNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9061,7 +9061,7 @@ func decodeTestRequestRequiredStringTimeArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9094,7 +9094,7 @@ func decodeTestRequestRequiredStringTimeNullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9127,7 +9127,7 @@ func decodeTestRequestRequiredStringTimeNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9160,7 +9160,7 @@ func decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURIResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9193,7 +9193,7 @@ func decodeTestRequestRequiredStringURIResponse(resp *http.Response, span trace. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURIArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9226,7 +9226,7 @@ func decodeTestRequestRequiredStringURIArrayResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURIArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9259,7 +9259,7 @@ func decodeTestRequestRequiredStringURIArrayArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURINullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9292,7 +9292,7 @@ func decodeTestRequestRequiredStringURINullableResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURINullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9325,7 +9325,7 @@ func decodeTestRequestRequiredStringURINullableArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9358,7 +9358,7 @@ func decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9391,7 +9391,7 @@ func decodeTestRequestRequiredStringUUIDResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9424,7 +9424,7 @@ func decodeTestRequestRequiredStringUUIDArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9457,7 +9457,7 @@ func decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv4Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9490,7 +9490,7 @@ func decodeTestRequestRequiredStringUUIDNullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv4ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9523,7 +9523,7 @@ func decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv4ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9556,7 +9556,7 @@ func decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv4NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9589,7 +9589,7 @@ func decodeTestRequestRequiredStringUnixResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv4NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9622,7 +9622,7 @@ func decodeTestRequestRequiredStringUnixArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9655,7 +9655,7 @@ func decodeTestRequestRequiredStringUnixArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv6Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9688,7 +9688,7 @@ func decodeTestRequestRequiredStringUnixMicroResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv6ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9721,7 +9721,7 @@ func decodeTestRequestRequiredStringUnixMicroArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv6ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9754,7 +9754,7 @@ func decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv6NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9787,7 +9787,7 @@ func decodeTestRequestRequiredStringUnixMicroNullableResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv6NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9820,7 +9820,7 @@ func decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9853,7 +9853,7 @@ func decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp *ht return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9886,7 +9886,7 @@ func decodeTestRequestRequiredStringUnixMilliResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9919,7 +9919,7 @@ func decodeTestRequestRequiredStringUnixMilliArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9952,7 +9952,7 @@ func decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringPasswordResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -9985,7 +9985,7 @@ func decodeTestRequestRequiredStringUnixMilliNullableResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringPasswordArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10018,7 +10018,7 @@ func decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10051,7 +10051,7 @@ func decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp *ht return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringPasswordNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10084,7 +10084,7 @@ func decodeTestRequestRequiredStringUnixNanoResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10117,7 +10117,7 @@ func decodeTestRequestRequiredStringUnixNanoArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10150,7 +10150,7 @@ func decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10183,7 +10183,7 @@ func decodeTestRequestRequiredStringUnixNanoNullableResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10216,7 +10216,7 @@ func decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10249,7 +10249,7 @@ func decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp *htt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10282,7 +10282,7 @@ func decodeTestRequestRequiredStringUnixNullableResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10315,7 +10315,7 @@ func decodeTestRequestRequiredStringUnixNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10348,7 +10348,7 @@ func decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringURIResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10381,7 +10381,7 @@ func decodeTestRequestRequiredStringUnixSecondsResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringURIArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10414,7 +10414,7 @@ func decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringURIArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10447,7 +10447,7 @@ func decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringURINullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10480,7 +10480,7 @@ func decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringURINullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10513,7 +10513,7 @@ func decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10546,7 +10546,7 @@ func decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUUIDResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10579,7 +10579,7 @@ func decodeTestRequestStringResponse(resp *http.Response, span trace.Span) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUUIDArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10612,7 +10612,7 @@ func decodeTestRequestStringArrayResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10645,7 +10645,7 @@ func decodeTestRequestStringArrayArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUUIDNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10678,7 +10678,7 @@ func decodeTestRequestStringBinaryResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10711,7 +10711,7 @@ func decodeTestRequestStringBinaryArrayResponse(resp *http.Response, span trace. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10744,7 +10744,7 @@ func decodeTestRequestStringBinaryArrayArrayResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10777,7 +10777,7 @@ func decodeTestRequestStringBinaryNullableResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10810,7 +10810,7 @@ func decodeTestRequestStringBinaryNullableArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10843,7 +10843,7 @@ func decodeTestRequestStringBinaryNullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10876,7 +10876,7 @@ func decodeTestRequestStringByteResponse(resp *http.Response, span trace.Span) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10909,7 +10909,7 @@ func decodeTestRequestStringByteArrayResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10942,7 +10942,7 @@ func decodeTestRequestStringByteArrayArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -10975,7 +10975,7 @@ func decodeTestRequestStringByteNullableResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11008,7 +11008,7 @@ func decodeTestRequestStringByteNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11041,7 +11041,7 @@ func decodeTestRequestStringByteNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11074,7 +11074,7 @@ func decodeTestRequestStringDateResponse(resp *http.Response, span trace.Span) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11107,7 +11107,7 @@ func decodeTestRequestStringDateArrayResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11140,7 +11140,7 @@ func decodeTestRequestStringDateArrayArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11173,7 +11173,7 @@ func decodeTestRequestStringDateNullableResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11206,7 +11206,7 @@ func decodeTestRequestStringDateNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11239,7 +11239,7 @@ func decodeTestRequestStringDateNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11272,7 +11272,7 @@ func decodeTestRequestStringDateTimeResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11305,7 +11305,7 @@ func decodeTestRequestStringDateTimeArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11338,7 +11338,7 @@ func decodeTestRequestStringDateTimeArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11371,7 +11371,7 @@ func decodeTestRequestStringDateTimeNullableResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11404,7 +11404,7 @@ func decodeTestRequestStringDateTimeNullableArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11437,7 +11437,7 @@ func decodeTestRequestStringDateTimeNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDurationResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11470,7 +11470,7 @@ func decodeTestRequestStringDurationResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDurationArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11503,7 +11503,7 @@ func decodeTestRequestStringDurationArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDurationArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11536,7 +11536,7 @@ func decodeTestRequestStringDurationArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDurationNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11569,7 +11569,7 @@ func decodeTestRequestStringDurationNullableResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDurationNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11602,7 +11602,7 @@ func decodeTestRequestStringDurationNullableArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDurationNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11635,7 +11635,7 @@ func decodeTestRequestStringDurationNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringEmailResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11668,7 +11668,7 @@ func decodeTestRequestStringEmailResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringEmailArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11701,7 +11701,7 @@ func decodeTestRequestStringEmailArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringEmailArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11734,7 +11734,7 @@ func decodeTestRequestStringEmailArrayArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringEmailNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11767,7 +11767,7 @@ func decodeTestRequestStringEmailNullableResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringEmailNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11800,7 +11800,7 @@ func decodeTestRequestStringEmailNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringEmailNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11833,7 +11833,7 @@ func decodeTestRequestStringEmailNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringHostnameResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringBinaryResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11866,7 +11866,7 @@ func decodeTestRequestStringHostnameResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringHostnameArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringBinaryArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11899,7 +11899,7 @@ func decodeTestRequestStringHostnameArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringHostnameArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringBinaryArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11932,7 +11932,7 @@ func decodeTestRequestStringHostnameArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringHostnameNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringBinaryNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11965,7 +11965,7 @@ func decodeTestRequestStringHostnameNullableResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringHostnameNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringBinaryNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -11998,7 +11998,7 @@ func decodeTestRequestStringHostnameNullableArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringHostnameNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringBinaryNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12031,7 +12031,7 @@ func decodeTestRequestStringHostnameNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIPResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringByteResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12064,7 +12064,7 @@ func decodeTestRequestStringIPResponse(resp *http.Response, span trace.Span) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIPArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringByteArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12097,7 +12097,7 @@ func decodeTestRequestStringIPArrayResponse(resp *http.Response, span trace.Span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIPArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringByteArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12130,7 +12130,7 @@ func decodeTestRequestStringIPArrayArrayResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIPNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringByteNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12163,7 +12163,7 @@ func decodeTestRequestStringIPNullableResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIPNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringByteNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12196,7 +12196,7 @@ func decodeTestRequestStringIPNullableArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIPNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringByteNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12229,7 +12229,7 @@ func decodeTestRequestStringIPNullableArrayArrayResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12262,7 +12262,7 @@ func decodeTestRequestStringInt32Response(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12295,7 +12295,7 @@ func decodeTestRequestStringInt32ArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12328,7 +12328,7 @@ func decodeTestRequestStringInt32ArrayArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12361,7 +12361,7 @@ func decodeTestRequestStringInt32NullableResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12394,7 +12394,7 @@ func decodeTestRequestStringInt32NullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12427,7 +12427,7 @@ func decodeTestRequestStringInt32NullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12460,7 +12460,7 @@ func decodeTestRequestStringInt64Response(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12493,7 +12493,7 @@ func decodeTestRequestStringInt64ArrayResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12526,7 +12526,7 @@ func decodeTestRequestStringInt64ArrayArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12559,7 +12559,7 @@ func decodeTestRequestStringInt64NullableResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12592,7 +12592,7 @@ func decodeTestRequestStringInt64NullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDateTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12625,7 +12625,7 @@ func decodeTestRequestStringInt64NullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv4Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDurationResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12658,7 +12658,7 @@ func decodeTestRequestStringIpv4Response(resp *http.Response, span trace.Span) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv4ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDurationArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12691,7 +12691,7 @@ func decodeTestRequestStringIpv4ArrayResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv4ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDurationArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12724,7 +12724,7 @@ func decodeTestRequestStringIpv4ArrayArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv4NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDurationNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12757,7 +12757,7 @@ func decodeTestRequestStringIpv4NullableResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv4NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDurationNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12790,7 +12790,7 @@ func decodeTestRequestStringIpv4NullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv4NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringDurationNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12823,7 +12823,7 @@ func decodeTestRequestStringIpv4NullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv6Response(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringEmailResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12856,7 +12856,7 @@ func decodeTestRequestStringIpv6Response(resp *http.Response, span trace.Span) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv6ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringEmailArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12889,7 +12889,7 @@ func decodeTestRequestStringIpv6ArrayResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv6ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringEmailArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12922,7 +12922,7 @@ func decodeTestRequestStringIpv6ArrayArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv6NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringEmailNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12955,7 +12955,7 @@ func decodeTestRequestStringIpv6NullableResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv6NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringEmailNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -12988,7 +12988,7 @@ func decodeTestRequestStringIpv6NullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringIpv6NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringEmailNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13021,7 +13021,7 @@ func decodeTestRequestStringIpv6NullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringHostnameResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13054,7 +13054,7 @@ func decodeTestRequestStringNullableResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringHostnameArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13087,7 +13087,7 @@ func decodeTestRequestStringNullableArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringHostnameArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13120,7 +13120,7 @@ func decodeTestRequestStringNullableArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringHostnameNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13153,7 +13153,7 @@ func decodeTestRequestStringPasswordResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringHostnameNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13186,7 +13186,7 @@ func decodeTestRequestStringPasswordArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringHostnameNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13219,7 +13219,7 @@ func decodeTestRequestStringPasswordArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIPResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13252,7 +13252,7 @@ func decodeTestRequestStringPasswordNullableResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIPArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13285,7 +13285,7 @@ func decodeTestRequestStringPasswordNullableArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIPArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13318,7 +13318,7 @@ func decodeTestRequestStringPasswordNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIPNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13351,7 +13351,7 @@ func decodeTestRequestStringTimeResponse(resp *http.Response, span trace.Span) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIPNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13384,7 +13384,7 @@ func decodeTestRequestStringTimeArrayResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIPNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13417,7 +13417,7 @@ func decodeTestRequestStringTimeArrayArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt32Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13450,7 +13450,7 @@ func decodeTestRequestStringTimeNullableResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt32ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13483,7 +13483,7 @@ func decodeTestRequestStringTimeNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13516,7 +13516,7 @@ func decodeTestRequestStringTimeNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURIResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt32NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13549,7 +13549,7 @@ func decodeTestRequestStringURIResponse(resp *http.Response, span trace.Span) (r return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURIArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13582,7 +13582,7 @@ func decodeTestRequestStringURIArrayResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURIArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13615,7 +13615,7 @@ func decodeTestRequestStringURIArrayArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURINullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt64Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13648,7 +13648,7 @@ func decodeTestRequestStringURINullableResponse(resp *http.Response, span trace. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURINullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt64ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13681,7 +13681,7 @@ func decodeTestRequestStringURINullableArrayResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURINullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13714,7 +13714,7 @@ func decodeTestRequestStringURINullableArrayArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt64NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13747,7 +13747,7 @@ func decodeTestRequestStringUUIDResponse(resp *http.Response, span trace.Span) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13780,7 +13780,7 @@ func decodeTestRequestStringUUIDArrayResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13813,7 +13813,7 @@ func decodeTestRequestStringUUIDArrayArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv4Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13846,7 +13846,7 @@ func decodeTestRequestStringUUIDNullableResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv4ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13879,7 +13879,7 @@ func decodeTestRequestStringUUIDNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv4ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13912,7 +13912,7 @@ func decodeTestRequestStringUUIDNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv4NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13945,7 +13945,7 @@ func decodeTestRequestStringUnixResponse(resp *http.Response, span trace.Span) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv4NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -13978,7 +13978,7 @@ func decodeTestRequestStringUnixArrayResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv4NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14011,7 +14011,7 @@ func decodeTestRequestStringUnixArrayArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv6Response(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14044,7 +14044,7 @@ func decodeTestRequestStringUnixMicroResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv6ArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14077,7 +14077,7 @@ func decodeTestRequestStringUnixMicroArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv6ArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14110,7 +14110,7 @@ func decodeTestRequestStringUnixMicroArrayArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv6NullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14143,7 +14143,7 @@ func decodeTestRequestStringUnixMicroNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv6NullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14176,7 +14176,7 @@ func decodeTestRequestStringUnixMicroNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringIpv6NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14209,7 +14209,7 @@ func decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14242,7 +14242,7 @@ func decodeTestRequestStringUnixMilliResponse(resp *http.Response, span trace.Sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14275,7 +14275,7 @@ func decodeTestRequestStringUnixMilliArrayResponse(resp *http.Response, span tra return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14308,7 +14308,7 @@ func decodeTestRequestStringUnixMilliArrayArrayResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringPasswordResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14341,7 +14341,7 @@ func decodeTestRequestStringUnixMilliNullableResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringPasswordArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14374,7 +14374,7 @@ func decodeTestRequestStringUnixMilliNullableArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringPasswordArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14407,7 +14407,7 @@ func decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringPasswordNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14440,7 +14440,7 @@ func decodeTestRequestStringUnixNanoResponse(resp *http.Response, span trace.Spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringPasswordNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14473,7 +14473,7 @@ func decodeTestRequestStringUnixNanoArrayResponse(resp *http.Response, span trac return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringPasswordNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14506,7 +14506,7 @@ func decodeTestRequestStringUnixNanoArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringTimeResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14539,7 +14539,7 @@ func decodeTestRequestStringUnixNanoNullableResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringTimeArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14572,7 +14572,7 @@ func decodeTestRequestStringUnixNanoNullableArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringTimeArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14605,7 +14605,7 @@ func decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringTimeNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14638,7 +14638,7 @@ func decodeTestRequestStringUnixNullableResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringTimeNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14671,7 +14671,7 @@ func decodeTestRequestStringUnixNullableArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringTimeNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14704,7 +14704,7 @@ func decodeTestRequestStringUnixNullableArrayArrayResponse(resp *http.Response, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringURIResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14737,7 +14737,7 @@ func decodeTestRequestStringUnixSecondsResponse(resp *http.Response, span trace. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringURIArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14770,7 +14770,7 @@ func decodeTestRequestStringUnixSecondsArrayResponse(resp *http.Response, span t return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringURIArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14803,7 +14803,7 @@ func decodeTestRequestStringUnixSecondsArrayArrayResponse(resp *http.Response, s return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringURINullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14836,7 +14836,7 @@ func decodeTestRequestStringUnixSecondsNullableResponse(resp *http.Response, spa return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringURINullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14869,7 +14869,7 @@ func decodeTestRequestStringUnixSecondsNullableArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { +func decodeTestRequestStringURINullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14902,7 +14902,7 @@ func decodeTestRequestStringUnixSecondsNullableArrayArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseAnyResponse(resp *http.Response, span trace.Span) (res jx.Raw, err error) { +func decodeTestRequestStringUUIDResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14918,11 +14918,9 @@ func decodeTestResponseAnyResponse(resp *http.Response, span trace.Span) (res jx } d := jx.DecodeBytes(b) - var response jx.Raw + var response Error if err := func() error { - v, err := d.RawAppend(nil) - response = jx.Raw(v) - if err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -14937,7 +14935,7 @@ func decodeTestResponseAnyResponse(resp *http.Response, span trace.Span) (res jx return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseBooleanResponse(resp *http.Response, span trace.Span) (res bool, err error) { +func decodeTestRequestStringUUIDArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14953,11 +14951,9 @@ func decodeTestResponseBooleanResponse(resp *http.Response, span trace.Span) (re } d := jx.DecodeBytes(b) - var response bool + var response Error if err := func() error { - v, err := d.Bool() - response = bool(v) - if err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -14972,7 +14968,7 @@ func decodeTestResponseBooleanResponse(resp *http.Response, span trace.Span) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseBooleanArrayResponse(resp *http.Response, span trace.Span) (res []bool, err error) { +func decodeTestRequestStringUUIDArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -14988,19 +14984,9 @@ func decodeTestResponseBooleanArrayResponse(resp *http.Response, span trace.Span } d := jx.DecodeBytes(b) - var response []bool + var response Error if err := func() error { - response = make([]bool, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem bool - v, err := d.Bool() - elem = bool(v) - if err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15015,7 +15001,7 @@ func decodeTestResponseBooleanArrayResponse(resp *http.Response, span trace.Span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseBooleanArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]bool, err error) { +func decodeTestRequestStringUUIDNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15031,27 +15017,9 @@ func decodeTestResponseBooleanArrayArrayResponse(resp *http.Response, span trace } d := jx.DecodeBytes(b) - var response [][]bool + var response Error if err := func() error { - response = make([][]bool, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem []bool - elem = make([]bool, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elemElem bool - v, err := d.Bool() - elemElem = bool(v) - if err != nil { - return err - } - elem = append(elem, elemElem) - return nil - }); err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15066,7 +15034,7 @@ func decodeTestResponseBooleanArrayArrayResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseBooleanNullableResponse(resp *http.Response, span trace.Span) (res NilBool, err error) { +func decodeTestRequestStringUUIDNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15082,7 +15050,7 @@ func decodeTestResponseBooleanNullableResponse(resp *http.Response, span trace.S } d := jx.DecodeBytes(b) - var response NilBool + var response Error if err := func() error { if err := response.Decode(d); err != nil { return err @@ -15099,7 +15067,7 @@ func decodeTestResponseBooleanNullableResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseBooleanNullableArrayResponse(resp *http.Response, span trace.Span) (res []NilBool, err error) { +func decodeTestRequestStringUUIDNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15115,17 +15083,9 @@ func decodeTestResponseBooleanNullableArrayResponse(resp *http.Response, span tr } d := jx.DecodeBytes(b) - var response []NilBool + var response Error if err := func() error { - response = make([]NilBool, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem NilBool - if err := elem.Decode(d); err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15140,7 +15100,7 @@ func decodeTestResponseBooleanNullableArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseBooleanNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilBool, err error) { +func decodeTestRequestStringUnixResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15156,25 +15116,9 @@ func decodeTestResponseBooleanNullableArrayArrayResponse(resp *http.Response, sp } d := jx.DecodeBytes(b) - var response [][]NilBool + var response Error if err := func() error { - response = make([][]NilBool, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilBool - elem = make([]NilBool, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilBool - if err := elemElem.Decode(d); err != nil { - return err - } - elem = append(elem, elemElem) - return nil - }); err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15189,7 +15133,7 @@ func decodeTestResponseBooleanNullableArrayArrayResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseEmptyStructResponse(resp *http.Response, span trace.Span) (res TestResponseEmptyStructOK, err error) { +func decodeTestRequestStringUnixArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15205,7 +15149,7 @@ func decodeTestResponseEmptyStructResponse(resp *http.Response, span trace.Span) } d := jx.DecodeBytes(b) - var response TestResponseEmptyStructOK + var response Error if err := func() error { if err := response.Decode(d); err != nil { return err @@ -15222,7 +15166,7 @@ func decodeTestResponseEmptyStructResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseFormatTestResponse(resp *http.Response, span trace.Span) (res TestResponseFormatTestOK, err error) { +func decodeTestRequestStringUnixArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15238,7 +15182,7 @@ func decodeTestResponseFormatTestResponse(resp *http.Response, span trace.Span) } d := jx.DecodeBytes(b) - var response TestResponseFormatTestOK + var response Error if err := func() error { if err := response.Decode(d); err != nil { return err @@ -15255,7 +15199,7 @@ func decodeTestResponseFormatTestResponse(resp *http.Response, span trace.Span) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerResponse(resp *http.Response, span trace.Span) (res int, err error) { +func decodeTestRequestStringUnixMicroResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15271,11 +15215,9 @@ func decodeTestResponseIntegerResponse(resp *http.Response, span trace.Span) (re } d := jx.DecodeBytes(b) - var response int + var response Error if err := func() error { - v, err := d.Int() - response = int(v) - if err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15290,7 +15232,7 @@ func decodeTestResponseIntegerResponse(resp *http.Response, span trace.Span) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerArrayResponse(resp *http.Response, span trace.Span) (res []int, err error) { +func decodeTestRequestStringUnixMicroArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15306,19 +15248,9 @@ func decodeTestResponseIntegerArrayResponse(resp *http.Response, span trace.Span } d := jx.DecodeBytes(b) - var response []int + var response Error if err := func() error { - response = make([]int, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem int - v, err := d.Int() - elem = int(v) - if err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15333,7 +15265,7 @@ func decodeTestResponseIntegerArrayResponse(resp *http.Response, span trace.Span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]int, err error) { +func decodeTestRequestStringUnixMicroArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15349,27 +15281,9 @@ func decodeTestResponseIntegerArrayArrayResponse(resp *http.Response, span trace } d := jx.DecodeBytes(b) - var response [][]int + var response Error if err := func() error { - response = make([][]int, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem []int - elem = make([]int, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int - v, err := d.Int() - elemElem = int(v) - if err != nil { - return err - } - elem = append(elem, elemElem) - return nil - }); err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15384,7 +15298,7 @@ func decodeTestResponseIntegerArrayArrayResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt32Response(resp *http.Response, span trace.Span) (res int32, err error) { +func decodeTestRequestStringUnixMicroNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15400,11 +15314,9 @@ func decodeTestResponseIntegerInt32Response(resp *http.Response, span trace.Span } d := jx.DecodeBytes(b) - var response int32 + var response Error if err := func() error { - v, err := d.Int32() - response = int32(v) - if err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15419,7 +15331,7 @@ func decodeTestResponseIntegerInt32Response(resp *http.Response, span trace.Span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt32ArrayResponse(resp *http.Response, span trace.Span) (res []int32, err error) { +func decodeTestRequestStringUnixMicroNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15435,19 +15347,9 @@ func decodeTestResponseIntegerInt32ArrayResponse(resp *http.Response, span trace } d := jx.DecodeBytes(b) - var response []int32 + var response Error if err := func() error { - response = make([]int32, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem int32 - v, err := d.Int32() - elem = int32(v) - if err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15462,7 +15364,7 @@ func decodeTestResponseIntegerInt32ArrayResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]int32, err error) { +func decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15478,27 +15380,9 @@ func decodeTestResponseIntegerInt32ArrayArrayResponse(resp *http.Response, span } d := jx.DecodeBytes(b) - var response [][]int32 + var response Error if err := func() error { - response = make([][]int32, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem []int32 - elem = make([]int32, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int32 - v, err := d.Int32() - elemElem = int32(v) - if err != nil { - return err - } - elem = append(elem, elemElem) - return nil - }); err != nil { - return err - } - response = append(response, elem) - return nil - }); err != nil { + if err := response.Decode(d); err != nil { return err } return nil @@ -15513,7 +15397,7 @@ func decodeTestResponseIntegerInt32ArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt32NullableResponse(resp *http.Response, span trace.Span) (res NilInt32, err error) { +func decodeTestRequestStringUnixMilliResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15529,7 +15413,7 @@ func decodeTestResponseIntegerInt32NullableResponse(resp *http.Response, span tr } d := jx.DecodeBytes(b) - var response NilInt32 + var response Error if err := func() error { if err := response.Decode(d); err != nil { return err @@ -15546,7 +15430,7 @@ func decodeTestResponseIntegerInt32NullableResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res []NilInt32, err error) { +func decodeTestRequestStringUnixMilliArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15562,14 +15446,1855 @@ func decodeTestResponseIntegerInt32NullableArrayResponse(resp *http.Response, sp } d := jx.DecodeBytes(b) - var response []NilInt32 + var response Error if err := func() error { - response = make([]NilInt32, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt32 - if err := elem.Decode(d); err != nil { - return err - } + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixMilliArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixMilliNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixMilliNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsNullableResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsNullableArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res Error, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseAnyResponse(resp *http.Response, span trace.Span) (res jx.Raw, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + response = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseBooleanResponse(resp *http.Response, span trace.Span) (res bool, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response bool + if err := func() error { + v, err := d.Bool() + response = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseBooleanArrayResponse(resp *http.Response, span trace.Span) (res []bool, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []bool + if err := func() error { + response = make([]bool, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem bool + v, err := d.Bool() + elem = bool(v) + if err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseBooleanArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]bool, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]bool + if err := func() error { + response = make([][]bool, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []bool + elem = make([]bool, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem bool + v, err := d.Bool() + elemElem = bool(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseBooleanNullableResponse(resp *http.Response, span trace.Span) (res NilBool, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response NilBool + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseBooleanNullableArrayResponse(resp *http.Response, span trace.Span) (res []NilBool, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []NilBool + if err := func() error { + response = make([]NilBool, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilBool + if err := elem.Decode(d); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseBooleanNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilBool, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]NilBool + if err := func() error { + response = make([][]NilBool, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilBool + elem = make([]NilBool, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilBool + if err := elemElem.Decode(d); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseEmptyStructResponse(resp *http.Response, span trace.Span) (res TestResponseEmptyStructOK, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response TestResponseEmptyStructOK + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseFormatTestResponse(resp *http.Response, span trace.Span) (res TestResponseFormatTestOK, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response TestResponseFormatTestOK + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerResponse(resp *http.Response, span trace.Span) (res int, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response int + if err := func() error { + v, err := d.Int() + response = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerArrayResponse(resp *http.Response, span trace.Span) (res []int, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []int + if err := func() error { + response = make([]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int + v, err := d.Int() + elem = int(v) + if err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]int, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]int + if err := func() error { + response = make([][]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []int + elem = make([]int, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem int + v, err := d.Int() + elemElem = int(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt32Response(resp *http.Response, span trace.Span) (res int32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response int32 + if err := func() error { + v, err := d.Int32() + response = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt32ArrayResponse(resp *http.Response, span trace.Span) (res []int32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []int32 + if err := func() error { + response = make([]int32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int32 + v, err := d.Int32() + elem = int32(v) + if err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt32ArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]int32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]int32 + if err := func() error { + response = make([][]int32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []int32 + elem = make([]int32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem int32 + v, err := d.Int32() + elemElem = int32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt32NullableResponse(resp *http.Response, span trace.Span) (res NilInt32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response NilInt32 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt32NullableArrayResponse(resp *http.Response, span trace.Span) (res []NilInt32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []NilInt32 + if err := func() error { + response = make([]NilInt32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilInt32 + if err := elem.Decode(d); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilInt32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]NilInt32 + if err := func() error { + response = make([][]NilInt32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilInt32 + elem = make([]NilInt32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilInt32 + if err := elemElem.Decode(d); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt64Response(resp *http.Response, span trace.Span) (res int64, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response int64 + if err := func() error { + v, err := d.Int64() + response = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt64ArrayResponse(resp *http.Response, span trace.Span) (res []int64, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []int64 + if err := func() error { + response = make([]int64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int64 + v, err := d.Int64() + elem = int64(v) + if err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]int64, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]int64 + if err := func() error { + response = make([][]int64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []int64 + elem = make([]int64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem int64 + v, err := d.Int64() + elemElem = int64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt64NullableResponse(resp *http.Response, span trace.Span) (res NilInt64, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response NilInt64 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res []NilInt64, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []NilInt64 + if err := func() error { + response = make([]NilInt64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilInt64 + if err := elem.Decode(d); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilInt64, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]NilInt64 + if err := func() error { + response = make([][]NilInt64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilInt64 + elem = make([]NilInt64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilInt64 + if err := elemElem.Decode(d); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerNullableResponse(resp *http.Response, span trace.Span) (res NilInt, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response NilInt + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerNullableArrayResponse(resp *http.Response, span trace.Span) (res []NilInt, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []NilInt + if err := func() error { + response = make([]NilInt, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilInt + if err := elem.Decode(d); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilInt, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]NilInt + if err := func() error { + response = make([][]NilInt, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilInt + elem = make([]NilInt, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilInt + if err := elemElem.Decode(d); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUintResponse(resp *http.Response, span trace.Span) (res uint, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response uint + if err := func() error { + v, err := d.UInt() + response = uint(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUint32Response(resp *http.Response, span trace.Span) (res uint32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response uint32 + if err := func() error { + v, err := d.UInt32() + response = uint32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUint32ArrayResponse(resp *http.Response, span trace.Span) (res []uint32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []uint32 + if err := func() error { + response = make([]uint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint32 + v, err := d.UInt32() + elem = uint32(v) + if err != nil { + return err + } response = append(response, elem) return nil }); err != nil { @@ -15587,7 +17312,7 @@ func decodeTestResponseIntegerInt32NullableArrayResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilInt32, err error) { +func decodeTestResponseIntegerUint32ArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]uint32, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15603,14 +17328,139 @@ func decodeTestResponseIntegerInt32NullableArrayArrayResponse(resp *http.Respons } d := jx.DecodeBytes(b) - var response [][]NilInt32 + var response [][]uint32 if err := func() error { - response = make([][]NilInt32, 0) + response = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt32 - elem = make([]NilInt32, 0) + var elem []uint32 + elem = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt32 + var elemElem uint32 + v, err := d.UInt32() + elemElem = uint32(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUint32NullableResponse(resp *http.Response, span trace.Span) (res NilUint32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response NilUint32 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUint32NullableArrayResponse(resp *http.Response, span trace.Span) (res []NilUint32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response []NilUint32 + if err := func() error { + response = make([]NilUint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilUint32 + if err := elem.Decode(d); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUint32NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilUint32, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]NilUint32 + if err := func() error { + response = make([][]NilUint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilUint32 + elem = make([]NilUint32, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilUint32 if err := elemElem.Decode(d); err != nil { return err } @@ -15636,7 +17486,7 @@ func decodeTestResponseIntegerInt32NullableArrayArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt64Response(resp *http.Response, span trace.Span) (res int64, err error) { +func decodeTestResponseIntegerUint64Response(resp *http.Response, span trace.Span) (res uint64, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15652,10 +17502,10 @@ func decodeTestResponseIntegerInt64Response(resp *http.Response, span trace.Span } d := jx.DecodeBytes(b) - var response int64 + var response uint64 if err := func() error { - v, err := d.Int64() - response = int64(v) + v, err := d.UInt64() + response = uint64(v) if err != nil { return err } @@ -15671,7 +17521,7 @@ func decodeTestResponseIntegerInt64Response(resp *http.Response, span trace.Span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt64ArrayResponse(resp *http.Response, span trace.Span) (res []int64, err error) { +func decodeTestResponseIntegerUint64ArrayResponse(resp *http.Response, span trace.Span) (res []uint64, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15687,13 +17537,13 @@ func decodeTestResponseIntegerInt64ArrayResponse(resp *http.Response, span trace } d := jx.DecodeBytes(b) - var response []int64 + var response []uint64 if err := func() error { - response = make([]int64, 0) + response = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int64 - v, err := d.Int64() - elem = int64(v) + var elem uint64 + v, err := d.UInt64() + elem = uint64(v) if err != nil { return err } @@ -15714,7 +17564,7 @@ func decodeTestResponseIntegerInt64ArrayResponse(resp *http.Response, span trace return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt64ArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]int64, err error) { +func decodeTestResponseIntegerUint64ArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]uint64, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15730,16 +17580,16 @@ func decodeTestResponseIntegerInt64ArrayArrayResponse(resp *http.Response, span } d := jx.DecodeBytes(b) - var response [][]int64 + var response [][]uint64 if err := func() error { - response = make([][]int64, 0) + response = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int64 - elem = make([]int64, 0) + var elem []uint64 + elem = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int64 - v, err := d.Int64() - elemElem = int64(v) + var elemElem uint64 + v, err := d.UInt64() + elemElem = uint64(v) if err != nil { return err } @@ -15765,7 +17615,7 @@ func decodeTestResponseIntegerInt64ArrayArrayResponse(resp *http.Response, span return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt64NullableResponse(resp *http.Response, span trace.Span) (res NilInt64, err error) { +func decodeTestResponseIntegerUint64NullableResponse(resp *http.Response, span trace.Span) (res NilUint64, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15781,7 +17631,7 @@ func decodeTestResponseIntegerInt64NullableResponse(resp *http.Response, span tr } d := jx.DecodeBytes(b) - var response NilInt64 + var response NilUint64 if err := func() error { if err := response.Decode(d); err != nil { return err @@ -15798,7 +17648,7 @@ func decodeTestResponseIntegerInt64NullableResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt64NullableArrayResponse(resp *http.Response, span trace.Span) (res []NilInt64, err error) { +func decodeTestResponseIntegerUint64NullableArrayResponse(resp *http.Response, span trace.Span) (res []NilUint64, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15814,11 +17664,11 @@ func decodeTestResponseIntegerInt64NullableArrayResponse(resp *http.Response, sp } d := jx.DecodeBytes(b) - var response []NilInt64 + var response []NilUint64 if err := func() error { - response = make([]NilInt64, 0) + response = make([]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt64 + var elem NilUint64 if err := elem.Decode(d); err != nil { return err } @@ -15839,7 +17689,7 @@ func decodeTestResponseIntegerInt64NullableArrayResponse(resp *http.Response, sp return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerInt64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilInt64, err error) { +func decodeTestResponseIntegerUint64NullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilUint64, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15855,14 +17705,14 @@ func decodeTestResponseIntegerInt64NullableArrayArrayResponse(resp *http.Respons } d := jx.DecodeBytes(b) - var response [][]NilInt64 + var response [][]NilUint64 if err := func() error { - response = make([][]NilInt64, 0) + response = make([][]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt64 - elem = make([]NilInt64, 0) + var elem []NilUint64 + elem = make([]NilUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt64 + var elemElem NilUint64 if err := elemElem.Decode(d); err != nil { return err } @@ -15888,7 +17738,7 @@ func decodeTestResponseIntegerInt64NullableArrayArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerNullableResponse(resp *http.Response, span trace.Span) (res NilInt, err error) { +func decodeTestResponseIntegerUintArrayResponse(resp *http.Response, span trace.Span) (res []uint, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15904,7 +17754,101 @@ func decodeTestResponseIntegerNullableResponse(resp *http.Response, span trace.S } d := jx.DecodeBytes(b) - var response NilInt + var response []uint + if err := func() error { + response = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uint + v, err := d.UInt() + elem = uint(v) + if err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUintArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]uint, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response [][]uint + if err := func() error { + response = make([][]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uint + elem = make([]uint, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uint + v, err := d.UInt() + elemElem = uint(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseIntegerUintNullableResponse(resp *http.Response, span trace.Span) (res NilUint, err error) { + switch resp.StatusCode { + case 200: + // Code 200. + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + b, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + + d := jx.DecodeBytes(b) + var response NilUint if err := func() error { if err := response.Decode(d); err != nil { return err @@ -15921,7 +17865,7 @@ func decodeTestResponseIntegerNullableResponse(resp *http.Response, span trace.S return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerNullableArrayResponse(resp *http.Response, span trace.Span) (res []NilInt, err error) { +func decodeTestResponseIntegerUintNullableArrayResponse(resp *http.Response, span trace.Span) (res []NilUint, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15937,11 +17881,11 @@ func decodeTestResponseIntegerNullableArrayResponse(resp *http.Response, span tr } d := jx.DecodeBytes(b) - var response []NilInt + var response []NilUint if err := func() error { - response = make([]NilInt, 0) + response = make([]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilInt + var elem NilUint if err := elem.Decode(d); err != nil { return err } @@ -15962,7 +17906,7 @@ func decodeTestResponseIntegerNullableArrayResponse(resp *http.Response, span tr return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseIntegerNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilInt, err error) { +func decodeTestResponseIntegerUintNullableArrayArrayResponse(resp *http.Response, span trace.Span) (res [][]NilUint, err error) { switch resp.StatusCode { case 200: // Code 200. @@ -15978,14 +17922,14 @@ func decodeTestResponseIntegerNullableArrayArrayResponse(resp *http.Response, sp } d := jx.DecodeBytes(b) - var response [][]NilInt + var response [][]NilUint if err := func() error { - response = make([][]NilInt, 0) + response = make([][]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilInt - elem = make([]NilInt, 0) + var elem []NilUint + elem = make([]NilUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilInt + var elemElem NilUint if err := elemElem.Decode(d); err != nil { return err } diff --git a/examples/ex_test_format/oas_response_encoders_gen.go b/examples/ex_test_format/oas_response_encoders_gen.go index 6bc1c3d04..924940af6 100644 --- a/examples/ex_test_format/oas_response_encoders_gen.go +++ b/examples/ex_test_format/oas_response_encoders_gen.go @@ -381,7 +381,7 @@ func encodeTestRequestIntegerNullableArrayArrayResponse(response Error, w http.R return nil } -func encodeTestRequestIntegerUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUintResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -394,7 +394,7 @@ func encodeTestRequestIntegerUnixResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestIntegerUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint32Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -407,7 +407,7 @@ func encodeTestRequestIntegerUnixArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestIntegerUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -420,7 +420,7 @@ func encodeTestRequestIntegerUnixArrayArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestIntegerUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -433,7 +433,7 @@ func encodeTestRequestIntegerUnixMicroResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestIntegerUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -446,7 +446,7 @@ func encodeTestRequestIntegerUnixMicroArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestIntegerUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -459,7 +459,7 @@ func encodeTestRequestIntegerUnixMicroArrayArrayResponse(response Error, w http. return nil } -func encodeTestRequestIntegerUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -472,7 +472,7 @@ func encodeTestRequestIntegerUnixMicroNullableResponse(response Error, w http.Re return nil } -func encodeTestRequestIntegerUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint64Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -485,7 +485,7 @@ func encodeTestRequestIntegerUnixMicroNullableArrayResponse(response Error, w ht return nil } -func encodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -498,7 +498,7 @@ func encodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(response Error, return nil } -func encodeTestRequestIntegerUnixMilliResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -511,7 +511,7 @@ func encodeTestRequestIntegerUnixMilliResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestIntegerUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -524,7 +524,7 @@ func encodeTestRequestIntegerUnixMilliArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestIntegerUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -537,7 +537,7 @@ func encodeTestRequestIntegerUnixMilliArrayArrayResponse(response Error, w http. return nil } -func encodeTestRequestIntegerUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUint64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -550,7 +550,7 @@ func encodeTestRequestIntegerUnixMilliNullableResponse(response Error, w http.Re return nil } -func encodeTestRequestIntegerUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUintArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -563,7 +563,7 @@ func encodeTestRequestIntegerUnixMilliNullableArrayResponse(response Error, w ht return nil } -func encodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUintArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -576,7 +576,7 @@ func encodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(response Error, return nil } -func encodeTestRequestIntegerUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUintNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -589,7 +589,7 @@ func encodeTestRequestIntegerUnixNanoResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestIntegerUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUintNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -602,7 +602,7 @@ func encodeTestRequestIntegerUnixNanoArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestIntegerUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUintNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -615,7 +615,7 @@ func encodeTestRequestIntegerUnixNanoArrayArrayResponse(response Error, w http.R return nil } -func encodeTestRequestIntegerUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -628,7 +628,7 @@ func encodeTestRequestIntegerUnixNanoNullableResponse(response Error, w http.Res return nil } -func encodeTestRequestIntegerUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -641,7 +641,7 @@ func encodeTestRequestIntegerUnixNanoNullableArrayResponse(response Error, w htt return nil } -func encodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -654,7 +654,7 @@ func encodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(response Error, return nil } -func encodeTestRequestIntegerUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -667,7 +667,7 @@ func encodeTestRequestIntegerUnixNullableResponse(response Error, w http.Respons return nil } -func encodeTestRequestIntegerUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -680,7 +680,7 @@ func encodeTestRequestIntegerUnixNullableArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestIntegerUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -693,7 +693,7 @@ func encodeTestRequestIntegerUnixNullableArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestIntegerUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -706,7 +706,7 @@ func encodeTestRequestIntegerUnixSecondsResponse(response Error, w http.Response return nil } -func encodeTestRequestIntegerUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -719,7 +719,7 @@ func encodeTestRequestIntegerUnixSecondsArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestIntegerUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -732,7 +732,7 @@ func encodeTestRequestIntegerUnixSecondsArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestIntegerUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMilliResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -745,7 +745,7 @@ func encodeTestRequestIntegerUnixSecondsNullableResponse(response Error, w http. return nil } -func encodeTestRequestIntegerUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -758,7 +758,7 @@ func encodeTestRequestIntegerUnixSecondsNullableArrayResponse(response Error, w return nil } -func encodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -771,7 +771,7 @@ func encodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestNullResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -784,7 +784,7 @@ func encodeTestRequestNullResponse(response Error, w http.ResponseWriter, span t return nil } -func encodeTestRequestNullArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -797,7 +797,7 @@ func encodeTestRequestNullArrayResponse(response Error, w http.ResponseWriter, s return nil } -func encodeTestRequestNullArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -810,7 +810,7 @@ func encodeTestRequestNullArrayArrayResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestNullNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -823,7 +823,7 @@ func encodeTestRequestNullNullableResponse(response Error, w http.ResponseWriter return nil } -func encodeTestRequestNullNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -836,7 +836,7 @@ func encodeTestRequestNullNullableArrayResponse(response Error, w http.ResponseW return nil } -func encodeTestRequestNullNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -849,7 +849,7 @@ func encodeTestRequestNullNullableArrayArrayResponse(response Error, w http.Resp return nil } -func encodeTestRequestNumberResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -862,7 +862,7 @@ func encodeTestRequestNumberResponse(response Error, w http.ResponseWriter, span return nil } -func encodeTestRequestNumberArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -875,7 +875,7 @@ func encodeTestRequestNumberArrayResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestNumberArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -888,7 +888,7 @@ func encodeTestRequestNumberArrayArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestNumberDoubleResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -901,7 +901,7 @@ func encodeTestRequestNumberDoubleResponse(response Error, w http.ResponseWriter return nil } -func encodeTestRequestNumberDoubleArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -914,7 +914,7 @@ func encodeTestRequestNumberDoubleArrayResponse(response Error, w http.ResponseW return nil } -func encodeTestRequestNumberDoubleArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -927,7 +927,7 @@ func encodeTestRequestNumberDoubleArrayArrayResponse(response Error, w http.Resp return nil } -func encodeTestRequestNumberDoubleNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -940,7 +940,7 @@ func encodeTestRequestNumberDoubleNullableResponse(response Error, w http.Respon return nil } -func encodeTestRequestNumberDoubleNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -953,7 +953,7 @@ func encodeTestRequestNumberDoubleNullableArrayResponse(response Error, w http.R return nil } -func encodeTestRequestNumberDoubleNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -966,7 +966,7 @@ func encodeTestRequestNumberDoubleNullableArrayArrayResponse(response Error, w h return nil } -func encodeTestRequestNumberFloatResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -979,7 +979,7 @@ func encodeTestRequestNumberFloatResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestNumberFloatArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -992,7 +992,7 @@ func encodeTestRequestNumberFloatArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestNumberFloatArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestIntegerUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1005,7 +1005,7 @@ func encodeTestRequestNumberFloatArrayArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestNumberFloatNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNullResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1018,7 +1018,7 @@ func encodeTestRequestNumberFloatNullableResponse(response Error, w http.Respons return nil } -func encodeTestRequestNumberFloatNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNullArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1031,7 +1031,7 @@ func encodeTestRequestNumberFloatNullableArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestNumberFloatNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNullArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1044,7 +1044,7 @@ func encodeTestRequestNumberFloatNullableArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestNumberInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNullNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1057,7 +1057,7 @@ func encodeTestRequestNumberInt32Response(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestNumberInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNullNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1070,7 +1070,7 @@ func encodeTestRequestNumberInt32ArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestNumberInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNullNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1083,7 +1083,7 @@ func encodeTestRequestNumberInt32ArrayArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestNumberInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1096,7 +1096,7 @@ func encodeTestRequestNumberInt32NullableResponse(response Error, w http.Respons return nil } -func encodeTestRequestNumberInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1109,7 +1109,7 @@ func encodeTestRequestNumberInt32NullableArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestNumberInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1122,7 +1122,7 @@ func encodeTestRequestNumberInt32NullableArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestNumberInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberDoubleResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1135,7 +1135,7 @@ func encodeTestRequestNumberInt64Response(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestNumberInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberDoubleArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1148,7 +1148,7 @@ func encodeTestRequestNumberInt64ArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestNumberInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberDoubleArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1161,7 +1161,7 @@ func encodeTestRequestNumberInt64ArrayArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestNumberInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberDoubleNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1174,7 +1174,7 @@ func encodeTestRequestNumberInt64NullableResponse(response Error, w http.Respons return nil } -func encodeTestRequestNumberInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberDoubleNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1187,7 +1187,7 @@ func encodeTestRequestNumberInt64NullableArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestNumberInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberDoubleNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1200,7 +1200,7 @@ func encodeTestRequestNumberInt64NullableArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestNumberNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberFloatResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1213,7 +1213,7 @@ func encodeTestRequestNumberNullableResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestNumberNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberFloatArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1226,7 +1226,7 @@ func encodeTestRequestNumberNullableArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestNumberNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberFloatArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1239,7 +1239,7 @@ func encodeTestRequestNumberNullableArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredAnyResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberFloatNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1252,7 +1252,7 @@ func encodeTestRequestRequiredAnyResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestRequiredBooleanResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberFloatNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1265,7 +1265,7 @@ func encodeTestRequestRequiredBooleanResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestRequiredBooleanArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberFloatNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1278,7 +1278,7 @@ func encodeTestRequestRequiredBooleanArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestRequiredBooleanArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1291,7 +1291,7 @@ func encodeTestRequestRequiredBooleanArrayArrayResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredBooleanNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1304,7 +1304,7 @@ func encodeTestRequestRequiredBooleanNullableResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredBooleanNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1317,7 +1317,7 @@ func encodeTestRequestRequiredBooleanNullableArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredBooleanNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1330,7 +1330,7 @@ func encodeTestRequestRequiredBooleanNullableArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredEmptyStructResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1343,7 +1343,7 @@ func encodeTestRequestRequiredEmptyStructResponse(response Error, w http.Respons return nil } -func encodeTestRequestRequiredFormatTestResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1356,7 +1356,7 @@ func encodeTestRequestRequiredFormatTestResponse(response Error, w http.Response return nil } -func encodeTestRequestRequiredIntegerResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1369,7 +1369,7 @@ func encodeTestRequestRequiredIntegerResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestRequiredIntegerArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1382,7 +1382,7 @@ func encodeTestRequestRequiredIntegerArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestRequiredIntegerArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1395,7 +1395,7 @@ func encodeTestRequestRequiredIntegerArrayArrayResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredIntegerInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1408,7 +1408,7 @@ func encodeTestRequestRequiredIntegerInt32Response(response Error, w http.Respon return nil } -func encodeTestRequestRequiredIntegerInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1421,7 +1421,7 @@ func encodeTestRequestRequiredIntegerInt32ArrayResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredIntegerInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1434,7 +1434,7 @@ func encodeTestRequestRequiredIntegerInt32ArrayArrayResponse(response Error, w h return nil } -func encodeTestRequestRequiredIntegerInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1447,7 +1447,7 @@ func encodeTestRequestRequiredIntegerInt32NullableResponse(response Error, w htt return nil } -func encodeTestRequestRequiredIntegerInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1460,7 +1460,7 @@ func encodeTestRequestRequiredIntegerInt32NullableArrayResponse(response Error, return nil } -func encodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestNumberNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1473,7 +1473,7 @@ func encodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(response Er return nil } -func encodeTestRequestRequiredIntegerInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredAnyResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1486,7 +1486,7 @@ func encodeTestRequestRequiredIntegerInt64Response(response Error, w http.Respon return nil } -func encodeTestRequestRequiredIntegerInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredBooleanResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1499,7 +1499,7 @@ func encodeTestRequestRequiredIntegerInt64ArrayResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredIntegerInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredBooleanArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1512,7 +1512,7 @@ func encodeTestRequestRequiredIntegerInt64ArrayArrayResponse(response Error, w h return nil } -func encodeTestRequestRequiredIntegerInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredBooleanArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1525,7 +1525,7 @@ func encodeTestRequestRequiredIntegerInt64NullableResponse(response Error, w htt return nil } -func encodeTestRequestRequiredIntegerInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredBooleanNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1538,7 +1538,7 @@ func encodeTestRequestRequiredIntegerInt64NullableArrayResponse(response Error, return nil } -func encodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredBooleanNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1551,7 +1551,7 @@ func encodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(response Er return nil } -func encodeTestRequestRequiredIntegerNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredBooleanNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1564,7 +1564,7 @@ func encodeTestRequestRequiredIntegerNullableResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredIntegerNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredEmptyStructResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1577,7 +1577,7 @@ func encodeTestRequestRequiredIntegerNullableArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredIntegerNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredFormatTestResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1590,7 +1590,7 @@ func encodeTestRequestRequiredIntegerNullableArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredIntegerUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1603,7 +1603,7 @@ func encodeTestRequestRequiredIntegerUnixResponse(response Error, w http.Respons return nil } -func encodeTestRequestRequiredIntegerUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1616,7 +1616,7 @@ func encodeTestRequestRequiredIntegerUnixArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredIntegerUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1629,7 +1629,7 @@ func encodeTestRequestRequiredIntegerUnixArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredIntegerUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1642,7 +1642,7 @@ func encodeTestRequestRequiredIntegerUnixMicroResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredIntegerUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1655,7 +1655,7 @@ func encodeTestRequestRequiredIntegerUnixMicroArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1668,7 +1668,7 @@ func encodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredIntegerUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1681,7 +1681,7 @@ func encodeTestRequestRequiredIntegerUnixMicroNullableResponse(response Error, w return nil } -func encodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1694,7 +1694,7 @@ func encodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(response Err return nil } -func encodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1707,7 +1707,7 @@ func encodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(respons return nil } -func encodeTestRequestRequiredIntegerUnixMilliResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1720,7 +1720,7 @@ func encodeTestRequestRequiredIntegerUnixMilliResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredIntegerUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1733,7 +1733,7 @@ func encodeTestRequestRequiredIntegerUnixMilliArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1746,7 +1746,7 @@ func encodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredIntegerUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1759,7 +1759,7 @@ func encodeTestRequestRequiredIntegerUnixMilliNullableResponse(response Error, w return nil } -func encodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1772,7 +1772,7 @@ func encodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(response Err return nil } -func encodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1785,7 +1785,7 @@ func encodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(respons return nil } -func encodeTestRequestRequiredIntegerUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1798,7 +1798,7 @@ func encodeTestRequestRequiredIntegerUnixNanoResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredIntegerUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1811,7 +1811,7 @@ func encodeTestRequestRequiredIntegerUnixNanoArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1824,7 +1824,7 @@ func encodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredIntegerUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUintResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1837,7 +1837,7 @@ func encodeTestRequestRequiredIntegerUnixNanoNullableResponse(response Error, w return nil } -func encodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint32Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1850,7 +1850,7 @@ func encodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(response Erro return nil } -func encodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1863,7 +1863,7 @@ func encodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredIntegerUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1876,7 +1876,7 @@ func encodeTestRequestRequiredIntegerUnixNullableResponse(response Error, w http return nil } -func encodeTestRequestRequiredIntegerUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1889,7 +1889,7 @@ func encodeTestRequestRequiredIntegerUnixNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1902,7 +1902,7 @@ func encodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(response Err return nil } -func encodeTestRequestRequiredIntegerUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1915,7 +1915,7 @@ func encodeTestRequestRequiredIntegerUnixSecondsResponse(response Error, w http. return nil } -func encodeTestRequestRequiredIntegerUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint64Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1928,7 +1928,7 @@ func encodeTestRequestRequiredIntegerUnixSecondsArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1941,7 +1941,7 @@ func encodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredIntegerUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1954,7 +1954,7 @@ func encodeTestRequestRequiredIntegerUnixSecondsNullableResponse(response Error, return nil } -func encodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1967,7 +1967,7 @@ func encodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(response E return nil } -func encodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1980,7 +1980,7 @@ func encodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(respo return nil } -func encodeTestRequestRequiredNullResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUint64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -1993,7 +1993,7 @@ func encodeTestRequestRequiredNullResponse(response Error, w http.ResponseWriter return nil } -func encodeTestRequestRequiredNullArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUintArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2006,7 +2006,7 @@ func encodeTestRequestRequiredNullArrayResponse(response Error, w http.ResponseW return nil } -func encodeTestRequestRequiredNullArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUintArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2019,7 +2019,7 @@ func encodeTestRequestRequiredNullArrayArrayResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredNullNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUintNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2032,7 +2032,7 @@ func encodeTestRequestRequiredNullNullableResponse(response Error, w http.Respon return nil } -func encodeTestRequestRequiredNullNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUintNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2045,7 +2045,7 @@ func encodeTestRequestRequiredNullNullableArrayResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredNullNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUintNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2058,7 +2058,7 @@ func encodeTestRequestRequiredNullNullableArrayArrayResponse(response Error, w h return nil } -func encodeTestRequestRequiredNumberResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2071,7 +2071,7 @@ func encodeTestRequestRequiredNumberResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestRequiredNumberArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2084,7 +2084,7 @@ func encodeTestRequestRequiredNumberArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestRequiredNumberArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2097,7 +2097,7 @@ func encodeTestRequestRequiredNumberArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredNumberDoubleResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2110,7 +2110,7 @@ func encodeTestRequestRequiredNumberDoubleResponse(response Error, w http.Respon return nil } -func encodeTestRequestRequiredNumberDoubleArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2123,7 +2123,7 @@ func encodeTestRequestRequiredNumberDoubleArrayResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredNumberDoubleArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2136,7 +2136,7 @@ func encodeTestRequestRequiredNumberDoubleArrayArrayResponse(response Error, w h return nil } -func encodeTestRequestRequiredNumberDoubleNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2149,7 +2149,7 @@ func encodeTestRequestRequiredNumberDoubleNullableResponse(response Error, w htt return nil } -func encodeTestRequestRequiredNumberDoubleNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2162,7 +2162,7 @@ func encodeTestRequestRequiredNumberDoubleNullableArrayResponse(response Error, return nil } -func encodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2175,7 +2175,7 @@ func encodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(response Er return nil } -func encodeTestRequestRequiredNumberFloatResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMilliResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2188,7 +2188,7 @@ func encodeTestRequestRequiredNumberFloatResponse(response Error, w http.Respons return nil } -func encodeTestRequestRequiredNumberFloatArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2201,7 +2201,7 @@ func encodeTestRequestRequiredNumberFloatArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredNumberFloatArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2214,7 +2214,7 @@ func encodeTestRequestRequiredNumberFloatArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredNumberFloatNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2227,7 +2227,7 @@ func encodeTestRequestRequiredNumberFloatNullableResponse(response Error, w http return nil } -func encodeTestRequestRequiredNumberFloatNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2240,7 +2240,7 @@ func encodeTestRequestRequiredNumberFloatNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2253,7 +2253,7 @@ func encodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(response Err return nil } -func encodeTestRequestRequiredNumberInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2266,7 +2266,7 @@ func encodeTestRequestRequiredNumberInt32Response(response Error, w http.Respons return nil } -func encodeTestRequestRequiredNumberInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2279,7 +2279,7 @@ func encodeTestRequestRequiredNumberInt32ArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredNumberInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2292,7 +2292,7 @@ func encodeTestRequestRequiredNumberInt32ArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredNumberInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2305,7 +2305,7 @@ func encodeTestRequestRequiredNumberInt32NullableResponse(response Error, w http return nil } -func encodeTestRequestRequiredNumberInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2318,7 +2318,7 @@ func encodeTestRequestRequiredNumberInt32NullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2331,7 +2331,7 @@ func encodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(response Err return nil } -func encodeTestRequestRequiredNumberInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2344,7 +2344,7 @@ func encodeTestRequestRequiredNumberInt64Response(response Error, w http.Respons return nil } -func encodeTestRequestRequiredNumberInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2357,7 +2357,7 @@ func encodeTestRequestRequiredNumberInt64ArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredNumberInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2370,7 +2370,7 @@ func encodeTestRequestRequiredNumberInt64ArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredNumberInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2383,7 +2383,7 @@ func encodeTestRequestRequiredNumberInt64NullableResponse(response Error, w http return nil } -func encodeTestRequestRequiredNumberInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2396,7 +2396,7 @@ func encodeTestRequestRequiredNumberInt64NullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2409,7 +2409,7 @@ func encodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(response Err return nil } -func encodeTestRequestRequiredNumberNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2422,7 +2422,7 @@ func encodeTestRequestRequiredNumberNullableResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredNumberNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2435,7 +2435,7 @@ func encodeTestRequestRequiredNumberNullableArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredNumberNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredIntegerUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2448,7 +2448,7 @@ func encodeTestRequestRequiredNumberNullableArrayArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNullResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2461,7 +2461,7 @@ func encodeTestRequestRequiredStringResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestRequiredStringArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNullArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2474,7 +2474,7 @@ func encodeTestRequestRequiredStringArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestRequiredStringArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNullArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2487,7 +2487,7 @@ func encodeTestRequestRequiredStringArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredStringBinaryResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNullNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2500,7 +2500,7 @@ func encodeTestRequestRequiredStringBinaryResponse(response Error, w http.Respon return nil } -func encodeTestRequestRequiredStringBinaryArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNullNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2513,7 +2513,7 @@ func encodeTestRequestRequiredStringBinaryArrayResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredStringBinaryArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNullNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2526,7 +2526,7 @@ func encodeTestRequestRequiredStringBinaryArrayArrayResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringBinaryNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2539,7 +2539,7 @@ func encodeTestRequestRequiredStringBinaryNullableResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringBinaryNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2552,7 +2552,7 @@ func encodeTestRequestRequiredStringBinaryNullableArrayResponse(response Error, return nil } -func encodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2565,7 +2565,7 @@ func encodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(response Er return nil } -func encodeTestRequestRequiredStringByteResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberDoubleResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2578,7 +2578,7 @@ func encodeTestRequestRequiredStringByteResponse(response Error, w http.Response return nil } -func encodeTestRequestRequiredStringByteArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberDoubleArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2591,7 +2591,7 @@ func encodeTestRequestRequiredStringByteArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringByteArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberDoubleArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2604,7 +2604,7 @@ func encodeTestRequestRequiredStringByteArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringByteNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberDoubleNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2617,7 +2617,7 @@ func encodeTestRequestRequiredStringByteNullableResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringByteNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberDoubleNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2630,7 +2630,7 @@ func encodeTestRequestRequiredStringByteNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringByteNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberDoubleNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2643,7 +2643,7 @@ func encodeTestRequestRequiredStringByteNullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringDateResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberFloatResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2656,7 +2656,7 @@ func encodeTestRequestRequiredStringDateResponse(response Error, w http.Response return nil } -func encodeTestRequestRequiredStringDateArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberFloatArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2669,7 +2669,7 @@ func encodeTestRequestRequiredStringDateArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringDateArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberFloatArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2682,7 +2682,7 @@ func encodeTestRequestRequiredStringDateArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringDateNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberFloatNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2695,7 +2695,7 @@ func encodeTestRequestRequiredStringDateNullableResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringDateNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberFloatNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2708,7 +2708,7 @@ func encodeTestRequestRequiredStringDateNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringDateNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberFloatNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2721,7 +2721,7 @@ func encodeTestRequestRequiredStringDateNullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringDateTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2734,7 +2734,7 @@ func encodeTestRequestRequiredStringDateTimeResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredStringDateTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2747,7 +2747,7 @@ func encodeTestRequestRequiredStringDateTimeArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringDateTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2760,7 +2760,7 @@ func encodeTestRequestRequiredStringDateTimeArrayArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringDateTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2773,7 +2773,7 @@ func encodeTestRequestRequiredStringDateTimeNullableResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringDateTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2786,7 +2786,7 @@ func encodeTestRequestRequiredStringDateTimeNullableArrayResponse(response Error return nil } -func encodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2799,7 +2799,7 @@ func encodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredStringDurationResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2812,7 +2812,7 @@ func encodeTestRequestRequiredStringDurationResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredStringDurationArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2825,7 +2825,7 @@ func encodeTestRequestRequiredStringDurationArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringDurationArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2838,7 +2838,7 @@ func encodeTestRequestRequiredStringDurationArrayArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringDurationNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2851,7 +2851,7 @@ func encodeTestRequestRequiredStringDurationNullableResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringDurationNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2864,7 +2864,7 @@ func encodeTestRequestRequiredStringDurationNullableArrayResponse(response Error return nil } -func encodeTestRequestRequiredStringDurationNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2877,7 +2877,7 @@ func encodeTestRequestRequiredStringDurationNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredStringEmailResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2890,7 +2890,7 @@ func encodeTestRequestRequiredStringEmailResponse(response Error, w http.Respons return nil } -func encodeTestRequestRequiredStringEmailArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2903,7 +2903,7 @@ func encodeTestRequestRequiredStringEmailArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredStringEmailArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredNumberNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2916,7 +2916,7 @@ func encodeTestRequestRequiredStringEmailArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredStringEmailNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2929,7 +2929,7 @@ func encodeTestRequestRequiredStringEmailNullableResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringEmailNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2942,7 +2942,7 @@ func encodeTestRequestRequiredStringEmailNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringEmailNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2955,7 +2955,7 @@ func encodeTestRequestRequiredStringEmailNullableArrayArrayResponse(response Err return nil } -func encodeTestRequestRequiredStringHostnameResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringBinaryResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2968,7 +2968,7 @@ func encodeTestRequestRequiredStringHostnameResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredStringHostnameArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringBinaryArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2981,7 +2981,7 @@ func encodeTestRequestRequiredStringHostnameArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringHostnameArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringBinaryArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -2994,7 +2994,7 @@ func encodeTestRequestRequiredStringHostnameArrayArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringHostnameNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringBinaryNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3007,7 +3007,7 @@ func encodeTestRequestRequiredStringHostnameNullableResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringHostnameNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringBinaryNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3020,7 +3020,7 @@ func encodeTestRequestRequiredStringHostnameNullableArrayResponse(response Error return nil } -func encodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringBinaryNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3033,7 +3033,7 @@ func encodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredStringIPResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringByteResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3046,7 +3046,7 @@ func encodeTestRequestRequiredStringIPResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestRequiredStringIPArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringByteArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3059,7 +3059,7 @@ func encodeTestRequestRequiredStringIPArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestRequiredStringIPArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringByteArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3072,7 +3072,7 @@ func encodeTestRequestRequiredStringIPArrayArrayResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringIPNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringByteNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3085,7 +3085,7 @@ func encodeTestRequestRequiredStringIPNullableResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredStringIPNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringByteNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3098,7 +3098,7 @@ func encodeTestRequestRequiredStringIPNullableArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredStringIPNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringByteNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3111,7 +3111,7 @@ func encodeTestRequestRequiredStringIPNullableArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredStringInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3124,7 +3124,7 @@ func encodeTestRequestRequiredStringInt32Response(response Error, w http.Respons return nil } -func encodeTestRequestRequiredStringInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3137,7 +3137,7 @@ func encodeTestRequestRequiredStringInt32ArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredStringInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3150,7 +3150,7 @@ func encodeTestRequestRequiredStringInt32ArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredStringInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3163,7 +3163,7 @@ func encodeTestRequestRequiredStringInt32NullableResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3176,7 +3176,7 @@ func encodeTestRequestRequiredStringInt32NullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3189,7 +3189,7 @@ func encodeTestRequestRequiredStringInt32NullableArrayArrayResponse(response Err return nil } -func encodeTestRequestRequiredStringInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3202,7 +3202,7 @@ func encodeTestRequestRequiredStringInt64Response(response Error, w http.Respons return nil } -func encodeTestRequestRequiredStringInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3215,7 +3215,7 @@ func encodeTestRequestRequiredStringInt64ArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestRequiredStringInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3228,7 +3228,7 @@ func encodeTestRequestRequiredStringInt64ArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestRequiredStringInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3241,7 +3241,7 @@ func encodeTestRequestRequiredStringInt64NullableResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3254,7 +3254,7 @@ func encodeTestRequestRequiredStringInt64NullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDateTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3267,7 +3267,7 @@ func encodeTestRequestRequiredStringInt64NullableArrayArrayResponse(response Err return nil } -func encodeTestRequestRequiredStringIpv4Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDurationResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3280,7 +3280,7 @@ func encodeTestRequestRequiredStringIpv4Response(response Error, w http.Response return nil } -func encodeTestRequestRequiredStringIpv4ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDurationArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3293,7 +3293,7 @@ func encodeTestRequestRequiredStringIpv4ArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringIpv4ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDurationArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3306,7 +3306,7 @@ func encodeTestRequestRequiredStringIpv4ArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringIpv4NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDurationNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3319,7 +3319,7 @@ func encodeTestRequestRequiredStringIpv4NullableResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringIpv4NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDurationNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3332,7 +3332,7 @@ func encodeTestRequestRequiredStringIpv4NullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringDurationNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3345,7 +3345,7 @@ func encodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringIpv6Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringEmailResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3358,7 +3358,7 @@ func encodeTestRequestRequiredStringIpv6Response(response Error, w http.Response return nil } -func encodeTestRequestRequiredStringIpv6ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringEmailArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3371,7 +3371,7 @@ func encodeTestRequestRequiredStringIpv6ArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringIpv6ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringEmailArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3384,7 +3384,7 @@ func encodeTestRequestRequiredStringIpv6ArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringIpv6NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringEmailNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3397,7 +3397,7 @@ func encodeTestRequestRequiredStringIpv6NullableResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringIpv6NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringEmailNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3410,7 +3410,7 @@ func encodeTestRequestRequiredStringIpv6NullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringEmailNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3423,7 +3423,7 @@ func encodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringHostnameResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3436,7 +3436,7 @@ func encodeTestRequestRequiredStringNullableResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredStringNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringHostnameArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3449,7 +3449,7 @@ func encodeTestRequestRequiredStringNullableArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringHostnameArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3462,7 +3462,7 @@ func encodeTestRequestRequiredStringNullableArrayArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringPasswordResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringHostnameNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3475,7 +3475,7 @@ func encodeTestRequestRequiredStringPasswordResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredStringPasswordArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringHostnameNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3488,7 +3488,7 @@ func encodeTestRequestRequiredStringPasswordArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringPasswordArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringHostnameNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3501,7 +3501,7 @@ func encodeTestRequestRequiredStringPasswordArrayArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringPasswordNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIPResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3514,7 +3514,7 @@ func encodeTestRequestRequiredStringPasswordNullableResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringPasswordNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIPArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3527,7 +3527,7 @@ func encodeTestRequestRequiredStringPasswordNullableArrayResponse(response Error return nil } -func encodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIPArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3540,7 +3540,7 @@ func encodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredStringTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIPNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3553,7 +3553,7 @@ func encodeTestRequestRequiredStringTimeResponse(response Error, w http.Response return nil } -func encodeTestRequestRequiredStringTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIPNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3566,7 +3566,7 @@ func encodeTestRequestRequiredStringTimeArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIPNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3579,7 +3579,7 @@ func encodeTestRequestRequiredStringTimeArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3592,7 +3592,7 @@ func encodeTestRequestRequiredStringTimeNullableResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3605,7 +3605,7 @@ func encodeTestRequestRequiredStringTimeNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3618,7 +3618,7 @@ func encodeTestRequestRequiredStringTimeNullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringURIResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3631,7 +3631,7 @@ func encodeTestRequestRequiredStringURIResponse(response Error, w http.ResponseW return nil } -func encodeTestRequestRequiredStringURIArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3644,7 +3644,7 @@ func encodeTestRequestRequiredStringURIArrayResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredStringURIArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3657,7 +3657,7 @@ func encodeTestRequestRequiredStringURIArrayArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringURINullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3670,7 +3670,7 @@ func encodeTestRequestRequiredStringURINullableResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredStringURINullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3683,7 +3683,7 @@ func encodeTestRequestRequiredStringURINullableArrayResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringURINullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3696,7 +3696,7 @@ func encodeTestRequestRequiredStringURINullableArrayArrayResponse(response Error return nil } -func encodeTestRequestRequiredStringUUIDResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3709,7 +3709,7 @@ func encodeTestRequestRequiredStringUUIDResponse(response Error, w http.Response return nil } -func encodeTestRequestRequiredStringUUIDArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3722,7 +3722,7 @@ func encodeTestRequestRequiredStringUUIDArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringUUIDArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3735,7 +3735,7 @@ func encodeTestRequestRequiredStringUUIDArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringUUIDNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv4Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3748,7 +3748,7 @@ func encodeTestRequestRequiredStringUUIDNullableResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringUUIDNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv4ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3761,7 +3761,7 @@ func encodeTestRequestRequiredStringUUIDNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv4ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3774,7 +3774,7 @@ func encodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv4NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3787,7 +3787,7 @@ func encodeTestRequestRequiredStringUnixResponse(response Error, w http.Response return nil } -func encodeTestRequestRequiredStringUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv4NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3800,7 +3800,7 @@ func encodeTestRequestRequiredStringUnixArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv4NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3813,7 +3813,7 @@ func encodeTestRequestRequiredStringUnixArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv6Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3826,7 +3826,7 @@ func encodeTestRequestRequiredStringUnixMicroResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv6ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3839,7 +3839,7 @@ func encodeTestRequestRequiredStringUnixMicroArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv6ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3852,7 +3852,7 @@ func encodeTestRequestRequiredStringUnixMicroArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredStringUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv6NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3865,7 +3865,7 @@ func encodeTestRequestRequiredStringUnixMicroNullableResponse(response Error, w return nil } -func encodeTestRequestRequiredStringUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv6NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3878,7 +3878,7 @@ func encodeTestRequestRequiredStringUnixMicroNullableArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3891,7 +3891,7 @@ func encodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredStringUnixMilliResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3904,7 +3904,7 @@ func encodeTestRequestRequiredStringUnixMilliResponse(response Error, w http.Res return nil } -func encodeTestRequestRequiredStringUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3917,7 +3917,7 @@ func encodeTestRequestRequiredStringUnixMilliArrayResponse(response Error, w htt return nil } -func encodeTestRequestRequiredStringUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3930,7 +3930,7 @@ func encodeTestRequestRequiredStringUnixMilliArrayArrayResponse(response Error, return nil } -func encodeTestRequestRequiredStringUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringPasswordResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3943,7 +3943,7 @@ func encodeTestRequestRequiredStringUnixMilliNullableResponse(response Error, w return nil } -func encodeTestRequestRequiredStringUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringPasswordArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3956,7 +3956,7 @@ func encodeTestRequestRequiredStringUnixMilliNullableArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringPasswordArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3969,7 +3969,7 @@ func encodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredStringUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringPasswordNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3982,7 +3982,7 @@ func encodeTestRequestRequiredStringUnixNanoResponse(response Error, w http.Resp return nil } -func encodeTestRequestRequiredStringUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringPasswordNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -3995,7 +3995,7 @@ func encodeTestRequestRequiredStringUnixNanoArrayResponse(response Error, w http return nil } -func encodeTestRequestRequiredStringUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4008,7 +4008,7 @@ func encodeTestRequestRequiredStringUnixNanoArrayArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4021,7 +4021,7 @@ func encodeTestRequestRequiredStringUnixNanoNullableResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4034,7 +4034,7 @@ func encodeTestRequestRequiredStringUnixNanoNullableArrayResponse(response Error return nil } -func encodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4047,7 +4047,7 @@ func encodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(response return nil } -func encodeTestRequestRequiredStringUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4060,7 +4060,7 @@ func encodeTestRequestRequiredStringUnixNullableResponse(response Error, w http. return nil } -func encodeTestRequestRequiredStringUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4073,7 +4073,7 @@ func encodeTestRequestRequiredStringUnixNullableArrayResponse(response Error, w return nil } -func encodeTestRequestRequiredStringUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4086,7 +4086,7 @@ func encodeTestRequestRequiredStringUnixNullableArrayArrayResponse(response Erro return nil } -func encodeTestRequestRequiredStringUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringURIResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4099,7 +4099,7 @@ func encodeTestRequestRequiredStringUnixSecondsResponse(response Error, w http.R return nil } -func encodeTestRequestRequiredStringUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringURIArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4112,7 +4112,7 @@ func encodeTestRequestRequiredStringUnixSecondsArrayResponse(response Error, w h return nil } -func encodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringURIArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4125,7 +4125,7 @@ func encodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(response Error return nil } -func encodeTestRequestRequiredStringUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringURINullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4138,7 +4138,7 @@ func encodeTestRequestRequiredStringUnixSecondsNullableResponse(response Error, return nil } -func encodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringURINullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4151,7 +4151,7 @@ func encodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(response Er return nil } -func encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringURINullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4164,7 +4164,7 @@ func encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(respon return nil } -func encodeTestRequestStringResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUUIDResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4177,7 +4177,7 @@ func encodeTestRequestStringResponse(response Error, w http.ResponseWriter, span return nil } -func encodeTestRequestStringArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUUIDArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4190,7 +4190,7 @@ func encodeTestRequestStringArrayResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUUIDArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4203,7 +4203,7 @@ func encodeTestRequestStringArrayArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestStringBinaryResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUUIDNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4216,7 +4216,7 @@ func encodeTestRequestStringBinaryResponse(response Error, w http.ResponseWriter return nil } -func encodeTestRequestStringBinaryArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUUIDNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4229,7 +4229,7 @@ func encodeTestRequestStringBinaryArrayResponse(response Error, w http.ResponseW return nil } -func encodeTestRequestStringBinaryArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4242,7 +4242,7 @@ func encodeTestRequestStringBinaryArrayArrayResponse(response Error, w http.Resp return nil } -func encodeTestRequestStringBinaryNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4255,7 +4255,7 @@ func encodeTestRequestStringBinaryNullableResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringBinaryNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4268,7 +4268,7 @@ func encodeTestRequestStringBinaryNullableArrayResponse(response Error, w http.R return nil } -func encodeTestRequestStringBinaryNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4281,7 +4281,7 @@ func encodeTestRequestStringBinaryNullableArrayArrayResponse(response Error, w h return nil } -func encodeTestRequestStringByteResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4294,7 +4294,7 @@ func encodeTestRequestStringByteResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringByteArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4307,7 +4307,7 @@ func encodeTestRequestStringByteArrayResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringByteArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4320,7 +4320,7 @@ func encodeTestRequestStringByteArrayArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringByteNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4333,7 +4333,7 @@ func encodeTestRequestStringByteNullableResponse(response Error, w http.Response return nil } -func encodeTestRequestStringByteNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4346,7 +4346,7 @@ func encodeTestRequestStringByteNullableArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestStringByteNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4359,7 +4359,7 @@ func encodeTestRequestStringByteNullableArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringDateResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMilliResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4372,7 +4372,7 @@ func encodeTestRequestStringDateResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringDateArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4385,7 +4385,7 @@ func encodeTestRequestStringDateArrayResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringDateArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4398,7 +4398,7 @@ func encodeTestRequestStringDateArrayArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringDateNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4411,7 +4411,7 @@ func encodeTestRequestStringDateNullableResponse(response Error, w http.Response return nil } -func encodeTestRequestStringDateNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4424,7 +4424,7 @@ func encodeTestRequestStringDateNullableArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestStringDateNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4437,7 +4437,7 @@ func encodeTestRequestStringDateNullableArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringDateTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4450,7 +4450,7 @@ func encodeTestRequestStringDateTimeResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestStringDateTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4463,7 +4463,7 @@ func encodeTestRequestStringDateTimeArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringDateTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4476,7 +4476,7 @@ func encodeTestRequestStringDateTimeArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringDateTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4489,7 +4489,7 @@ func encodeTestRequestStringDateTimeNullableResponse(response Error, w http.Resp return nil } -func encodeTestRequestStringDateTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4502,7 +4502,7 @@ func encodeTestRequestStringDateTimeNullableArrayResponse(response Error, w http return nil } -func encodeTestRequestStringDateTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4515,7 +4515,7 @@ func encodeTestRequestStringDateTimeNullableArrayArrayResponse(response Error, w return nil } -func encodeTestRequestStringDurationResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4528,7 +4528,7 @@ func encodeTestRequestStringDurationResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestStringDurationArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4541,7 +4541,7 @@ func encodeTestRequestStringDurationArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringDurationArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4554,7 +4554,7 @@ func encodeTestRequestStringDurationArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringDurationNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4567,7 +4567,7 @@ func encodeTestRequestStringDurationNullableResponse(response Error, w http.Resp return nil } -func encodeTestRequestStringDurationNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4580,7 +4580,7 @@ func encodeTestRequestStringDurationNullableArrayResponse(response Error, w http return nil } -func encodeTestRequestStringDurationNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4593,7 +4593,7 @@ func encodeTestRequestStringDurationNullableArrayArrayResponse(response Error, w return nil } -func encodeTestRequestStringEmailResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4606,7 +4606,7 @@ func encodeTestRequestStringEmailResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringEmailArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4619,7 +4619,7 @@ func encodeTestRequestStringEmailArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestStringEmailArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4632,7 +4632,7 @@ func encodeTestRequestStringEmailArrayArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestStringEmailNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4645,7 +4645,7 @@ func encodeTestRequestStringEmailNullableResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringEmailNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4658,7 +4658,7 @@ func encodeTestRequestStringEmailNullableArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringEmailNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4671,7 +4671,7 @@ func encodeTestRequestStringEmailNullableArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestStringHostnameResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringBinaryResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4684,7 +4684,7 @@ func encodeTestRequestStringHostnameResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestStringHostnameArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringBinaryArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4697,7 +4697,7 @@ func encodeTestRequestStringHostnameArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringHostnameArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringBinaryArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4710,7 +4710,7 @@ func encodeTestRequestStringHostnameArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringHostnameNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringBinaryNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4723,7 +4723,7 @@ func encodeTestRequestStringHostnameNullableResponse(response Error, w http.Resp return nil } -func encodeTestRequestStringHostnameNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringBinaryNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4736,7 +4736,7 @@ func encodeTestRequestStringHostnameNullableArrayResponse(response Error, w http return nil } -func encodeTestRequestStringHostnameNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringBinaryNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4749,7 +4749,7 @@ func encodeTestRequestStringHostnameNullableArrayArrayResponse(response Error, w return nil } -func encodeTestRequestStringIPResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringByteResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4762,7 +4762,7 @@ func encodeTestRequestStringIPResponse(response Error, w http.ResponseWriter, sp return nil } -func encodeTestRequestStringIPArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringByteArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4775,7 +4775,7 @@ func encodeTestRequestStringIPArrayResponse(response Error, w http.ResponseWrite return nil } -func encodeTestRequestStringIPArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringByteArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4788,7 +4788,7 @@ func encodeTestRequestStringIPArrayArrayResponse(response Error, w http.Response return nil } -func encodeTestRequestStringIPNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringByteNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4801,7 +4801,7 @@ func encodeTestRequestStringIPNullableResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestStringIPNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringByteNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4814,7 +4814,7 @@ func encodeTestRequestStringIPNullableArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestStringIPNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringByteNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4827,7 +4827,7 @@ func encodeTestRequestStringIPNullableArrayArrayResponse(response Error, w http. return nil } -func encodeTestRequestStringInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4840,7 +4840,7 @@ func encodeTestRequestStringInt32Response(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4853,7 +4853,7 @@ func encodeTestRequestStringInt32ArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestStringInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4866,7 +4866,7 @@ func encodeTestRequestStringInt32ArrayArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestStringInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4879,7 +4879,7 @@ func encodeTestRequestStringInt32NullableResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4892,7 +4892,7 @@ func encodeTestRequestStringInt32NullableArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4905,7 +4905,7 @@ func encodeTestRequestStringInt32NullableArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestStringInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4918,7 +4918,7 @@ func encodeTestRequestStringInt64Response(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4931,7 +4931,7 @@ func encodeTestRequestStringInt64ArrayResponse(response Error, w http.ResponseWr return nil } -func encodeTestRequestStringInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4944,7 +4944,7 @@ func encodeTestRequestStringInt64ArrayArrayResponse(response Error, w http.Respo return nil } -func encodeTestRequestStringInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4957,7 +4957,7 @@ func encodeTestRequestStringInt64NullableResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4970,7 +4970,7 @@ func encodeTestRequestStringInt64NullableArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDateTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4983,7 +4983,7 @@ func encodeTestRequestStringInt64NullableArrayArrayResponse(response Error, w ht return nil } -func encodeTestRequestStringIpv4Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDurationResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -4996,7 +4996,7 @@ func encodeTestRequestStringIpv4Response(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringIpv4ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDurationArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5009,7 +5009,7 @@ func encodeTestRequestStringIpv4ArrayResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringIpv4ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDurationArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5022,7 +5022,7 @@ func encodeTestRequestStringIpv4ArrayArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringIpv4NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDurationNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5035,7 +5035,7 @@ func encodeTestRequestStringIpv4NullableResponse(response Error, w http.Response return nil } -func encodeTestRequestStringIpv4NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDurationNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5048,7 +5048,7 @@ func encodeTestRequestStringIpv4NullableArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestStringIpv4NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringDurationNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5061,7 +5061,7 @@ func encodeTestRequestStringIpv4NullableArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringIpv6Response(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringEmailResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5074,7 +5074,7 @@ func encodeTestRequestStringIpv6Response(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringIpv6ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringEmailArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5087,7 +5087,7 @@ func encodeTestRequestStringIpv6ArrayResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringIpv6ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringEmailArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5100,7 +5100,7 @@ func encodeTestRequestStringIpv6ArrayArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringIpv6NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringEmailNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5113,7 +5113,7 @@ func encodeTestRequestStringIpv6NullableResponse(response Error, w http.Response return nil } -func encodeTestRequestStringIpv6NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringEmailNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5126,7 +5126,7 @@ func encodeTestRequestStringIpv6NullableArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestStringIpv6NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringEmailNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5139,7 +5139,7 @@ func encodeTestRequestStringIpv6NullableArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringHostnameResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5152,7 +5152,7 @@ func encodeTestRequestStringNullableResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestStringNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringHostnameArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5165,7 +5165,7 @@ func encodeTestRequestStringNullableArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringHostnameArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5178,7 +5178,7 @@ func encodeTestRequestStringNullableArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringPasswordResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringHostnameNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5191,7 +5191,7 @@ func encodeTestRequestStringPasswordResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestStringPasswordArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringHostnameNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5204,7 +5204,7 @@ func encodeTestRequestStringPasswordArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringPasswordArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringHostnameNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5217,7 +5217,7 @@ func encodeTestRequestStringPasswordArrayArrayResponse(response Error, w http.Re return nil } -func encodeTestRequestStringPasswordNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIPResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5230,7 +5230,7 @@ func encodeTestRequestStringPasswordNullableResponse(response Error, w http.Resp return nil } -func encodeTestRequestStringPasswordNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIPArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5243,7 +5243,7 @@ func encodeTestRequestStringPasswordNullableArrayResponse(response Error, w http return nil } -func encodeTestRequestStringPasswordNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIPArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5256,7 +5256,7 @@ func encodeTestRequestStringPasswordNullableArrayArrayResponse(response Error, w return nil } -func encodeTestRequestStringTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIPNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5269,7 +5269,7 @@ func encodeTestRequestStringTimeResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIPNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5282,7 +5282,7 @@ func encodeTestRequestStringTimeArrayResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIPNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5295,7 +5295,7 @@ func encodeTestRequestStringTimeArrayArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt32Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5308,7 +5308,7 @@ func encodeTestRequestStringTimeNullableResponse(response Error, w http.Response return nil } -func encodeTestRequestStringTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt32ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5321,7 +5321,7 @@ func encodeTestRequestStringTimeNullableArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestStringTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt32ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5334,7 +5334,7 @@ func encodeTestRequestStringTimeNullableArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringURIResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt32NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5347,7 +5347,7 @@ func encodeTestRequestStringURIResponse(response Error, w http.ResponseWriter, s return nil } -func encodeTestRequestStringURIArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt32NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5360,7 +5360,7 @@ func encodeTestRequestStringURIArrayResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestStringURIArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt32NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5373,7 +5373,7 @@ func encodeTestRequestStringURIArrayArrayResponse(response Error, w http.Respons return nil } -func encodeTestRequestStringURINullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt64Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5386,7 +5386,7 @@ func encodeTestRequestStringURINullableResponse(response Error, w http.ResponseW return nil } -func encodeTestRequestStringURINullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt64ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5399,7 +5399,7 @@ func encodeTestRequestStringURINullableArrayResponse(response Error, w http.Resp return nil } -func encodeTestRequestStringURINullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt64ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5412,7 +5412,7 @@ func encodeTestRequestStringURINullableArrayArrayResponse(response Error, w http return nil } -func encodeTestRequestStringUUIDResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt64NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5425,7 +5425,7 @@ func encodeTestRequestStringUUIDResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringUUIDArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt64NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5438,7 +5438,7 @@ func encodeTestRequestStringUUIDArrayResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringUUIDArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringInt64NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5451,7 +5451,7 @@ func encodeTestRequestStringUUIDArrayArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringUUIDNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv4Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5464,7 +5464,7 @@ func encodeTestRequestStringUUIDNullableResponse(response Error, w http.Response return nil } -func encodeTestRequestStringUUIDNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv4ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5477,7 +5477,7 @@ func encodeTestRequestStringUUIDNullableArrayResponse(response Error, w http.Res return nil } -func encodeTestRequestStringUUIDNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv4ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5490,7 +5490,7 @@ func encodeTestRequestStringUUIDNullableArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv4NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5503,7 +5503,7 @@ func encodeTestRequestStringUnixResponse(response Error, w http.ResponseWriter, return nil } -func encodeTestRequestStringUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv4NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5516,7 +5516,7 @@ func encodeTestRequestStringUnixArrayResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv4NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5529,7 +5529,7 @@ func encodeTestRequestStringUnixArrayArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv6Response(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5542,7 +5542,7 @@ func encodeTestRequestStringUnixMicroResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv6ArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5555,7 +5555,7 @@ func encodeTestRequestStringUnixMicroArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv6ArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5568,7 +5568,7 @@ func encodeTestRequestStringUnixMicroArrayArrayResponse(response Error, w http.R return nil } -func encodeTestRequestStringUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv6NullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5581,7 +5581,7 @@ func encodeTestRequestStringUnixMicroNullableResponse(response Error, w http.Res return nil } -func encodeTestRequestStringUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv6NullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5594,7 +5594,475 @@ func encodeTestRequestStringUnixMicroNullableArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringIpv6NullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringPasswordResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringPasswordArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringPasswordArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringPasswordNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringPasswordNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringPasswordNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringTimeResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringTimeArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringTimeArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringTimeNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringTimeNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringTimeNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringURIResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringURIArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringURIArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringURINullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringURINullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringURINullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUUIDResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUUIDArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUUIDArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUUIDNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUUIDNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUUIDNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMicroResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMicroArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMicroArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMicroNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMicroNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMicroNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5620,7 +6088,189 @@ func encodeTestRequestStringUnixMilliResponse(response Error, w http.ResponseWri return nil } -func encodeTestRequestStringUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringUnixMilliArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestRequestStringUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5633,7 +6283,7 @@ func encodeTestRequestStringUnixMilliArrayResponse(response Error, w http.Respon return nil } -func encodeTestRequestStringUnixMilliArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5646,7 +6296,7 @@ func encodeTestRequestStringUnixMilliArrayArrayResponse(response Error, w http.R return nil } -func encodeTestRequestStringUnixMilliNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5659,7 +6309,7 @@ func encodeTestRequestStringUnixMilliNullableResponse(response Error, w http.Res return nil } -func encodeTestRequestStringUnixMilliNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5672,7 +6322,7 @@ func encodeTestRequestStringUnixMilliNullableArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringUnixMilliNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5685,7 +6335,7 @@ func encodeTestRequestStringUnixMilliNullableArrayArrayResponse(response Error, return nil } -func encodeTestRequestStringUnixNanoResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestRequestStringUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5698,59 +6348,73 @@ func encodeTestRequestStringUnixNanoResponse(response Error, w http.ResponseWrit return nil } -func encodeTestRequestStringUnixNanoArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseAnyResponse(response jx.Raw, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + if len(response) != 0 { + e.Raw(response) + } if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixNanoArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseBooleanResponse(response bool, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.Bool(response) if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixNanoNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseBooleanArrayResponse(response []bool, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + e.Bool(elem) + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixNanoNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseBooleanArrayArrayResponse(response [][]bool, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + e.ArrStart() + for _, elem := range elem { + e.Bool(elem) + } + e.ArrEnd() + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixNanoNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseBooleanNullableResponse(response NilBool, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5763,33 +6427,45 @@ func encodeTestRequestStringUnixNanoNullableArrayArrayResponse(response Error, w return nil } -func encodeTestRequestStringUnixNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseBooleanNullableArrayResponse(response []NilBool, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + elem.Encode(e) + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseBooleanNullableArrayArrayResponse(response [][]NilBool, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseEmptyStructResponse(response TestResponseEmptyStructOK, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5802,7 +6478,7 @@ func encodeTestRequestStringUnixNullableArrayArrayResponse(response Error, w htt return nil } -func encodeTestRequestStringUnixSecondsResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseFormatTestResponse(response TestResponseFormatTestOK, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5815,100 +6491,122 @@ func encodeTestRequestStringUnixSecondsResponse(response Error, w http.ResponseW return nil } -func encodeTestRequestStringUnixSecondsArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerResponse(response int, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.Int(response) if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixSecondsArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerArrayResponse(response []int, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + e.Int(elem) + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixSecondsNullableResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerArrayArrayResponse(response [][]int, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + e.ArrStart() + for _, elem := range elem { + e.Int(elem) + } + e.ArrEnd() + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixSecondsNullableArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt32Response(response int32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.Int32(response) if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestRequestStringUnixSecondsNullableArrayArrayResponse(response Error, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt32ArrayResponse(response []int32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + e.Int32(elem) + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseAnyResponse(response jx.Raw, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt32ArrayArrayResponse(response [][]int32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - if len(response) != 0 { - e.Raw(response) + e.ArrStart() + for _, elem := range response { + e.ArrStart() + for _, elem := range elem { + e.Int32(elem) + } + e.ArrEnd() } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseBooleanResponse(response bool, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt32NullableResponse(response NilInt32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - e.Bool(response) + response.Encode(e) if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseBooleanArrayResponse(response []bool, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt32NullableArrayResponse(response []NilInt32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5916,7 +6614,7 @@ func encodeTestResponseBooleanArrayResponse(response []bool, w http.ResponseWrit e.ArrStart() for _, elem := range response { - e.Bool(elem) + elem.Encode(e) } e.ArrEnd() if _, err := e.WriteTo(w); err != nil { @@ -5925,7 +6623,7 @@ func encodeTestResponseBooleanArrayResponse(response []bool, w http.ResponseWrit return nil } -func encodeTestResponseBooleanArrayArrayResponse(response [][]bool, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt32NullableArrayArrayResponse(response [][]NilInt32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5935,7 +6633,7 @@ func encodeTestResponseBooleanArrayArrayResponse(response [][]bool, w http.Respo for _, elem := range response { e.ArrStart() for _, elem := range elem { - e.Bool(elem) + elem.Encode(e) } e.ArrEnd() } @@ -5946,20 +6644,20 @@ func encodeTestResponseBooleanArrayArrayResponse(response [][]bool, w http.Respo return nil } -func encodeTestResponseBooleanNullableResponse(response NilBool, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt64Response(response int64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.Int64(response) if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseBooleanNullableArrayResponse(response []NilBool, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt64ArrayResponse(response []int64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5967,7 +6665,7 @@ func encodeTestResponseBooleanNullableArrayResponse(response []NilBool, w http.R e.ArrStart() for _, elem := range response { - elem.Encode(e) + e.Int64(elem) } e.ArrEnd() if _, err := e.WriteTo(w); err != nil { @@ -5976,7 +6674,7 @@ func encodeTestResponseBooleanNullableArrayResponse(response []NilBool, w http.R return nil } -func encodeTestResponseBooleanNullableArrayArrayResponse(response [][]NilBool, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt64ArrayArrayResponse(response [][]int64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -5986,7 +6684,7 @@ func encodeTestResponseBooleanNullableArrayArrayResponse(response [][]NilBool, w for _, elem := range response { e.ArrStart() for _, elem := range elem { - elem.Encode(e) + e.Int64(elem) } e.ArrEnd() } @@ -5997,7 +6695,7 @@ func encodeTestResponseBooleanNullableArrayArrayResponse(response [][]NilBool, w return nil } -func encodeTestResponseEmptyStructResponse(response TestResponseEmptyStructOK, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt64NullableResponse(response NilInt64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6010,33 +6708,58 @@ func encodeTestResponseEmptyStructResponse(response TestResponseEmptyStructOK, w return nil } -func encodeTestResponseFormatTestResponse(response TestResponseFormatTestOK, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt64NullableArrayResponse(response []NilInt64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - response.Encode(e) + e.ArrStart() + for _, elem := range response { + elem.Encode(e) + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseIntegerResponse(response int, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerInt64NullableArrayArrayResponse(response [][]NilInt64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - e.Int(response) + e.ArrStart() + for _, elem := range response { + e.ArrStart() + for _, elem := range elem { + elem.Encode(e) + } + e.ArrEnd() + } + e.ArrEnd() if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseIntegerArrayResponse(response []int, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerNullableResponse(response NilInt, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestResponseIntegerNullableArrayResponse(response []NilInt, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6044,7 +6767,7 @@ func encodeTestResponseIntegerArrayResponse(response []int, w http.ResponseWrite e.ArrStart() for _, elem := range response { - e.Int(elem) + elem.Encode(e) } e.ArrEnd() if _, err := e.WriteTo(w); err != nil { @@ -6053,7 +6776,7 @@ func encodeTestResponseIntegerArrayResponse(response []int, w http.ResponseWrite return nil } -func encodeTestResponseIntegerArrayArrayResponse(response [][]int, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerNullableArrayArrayResponse(response [][]NilInt, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6063,7 +6786,7 @@ func encodeTestResponseIntegerArrayArrayResponse(response [][]int, w http.Respon for _, elem := range response { e.ArrStart() for _, elem := range elem { - e.Int(elem) + elem.Encode(e) } e.ArrEnd() } @@ -6074,20 +6797,33 @@ func encodeTestResponseIntegerArrayArrayResponse(response [][]int, w http.Respon return nil } -func encodeTestResponseIntegerInt32Response(response int32, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUintResponse(response uint, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - e.Int32(response) + e.UInt(response) if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseIntegerInt32ArrayResponse(response []int32, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint32Response(response uint32, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + e.UInt32(response) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestResponseIntegerUint32ArrayResponse(response []uint32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6095,7 +6831,7 @@ func encodeTestResponseIntegerInt32ArrayResponse(response []int32, w http.Respon e.ArrStart() for _, elem := range response { - e.Int32(elem) + e.UInt32(elem) } e.ArrEnd() if _, err := e.WriteTo(w); err != nil { @@ -6104,7 +6840,7 @@ func encodeTestResponseIntegerInt32ArrayResponse(response []int32, w http.Respon return nil } -func encodeTestResponseIntegerInt32ArrayArrayResponse(response [][]int32, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint32ArrayArrayResponse(response [][]uint32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6114,7 +6850,7 @@ func encodeTestResponseIntegerInt32ArrayArrayResponse(response [][]int32, w http for _, elem := range response { e.ArrStart() for _, elem := range elem { - e.Int32(elem) + e.UInt32(elem) } e.ArrEnd() } @@ -6125,7 +6861,7 @@ func encodeTestResponseIntegerInt32ArrayArrayResponse(response [][]int32, w http return nil } -func encodeTestResponseIntegerInt32NullableResponse(response NilInt32, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint32NullableResponse(response NilUint32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6138,7 +6874,7 @@ func encodeTestResponseIntegerInt32NullableResponse(response NilInt32, w http.Re return nil } -func encodeTestResponseIntegerInt32NullableArrayResponse(response []NilInt32, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint32NullableArrayResponse(response []NilUint32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6155,7 +6891,7 @@ func encodeTestResponseIntegerInt32NullableArrayResponse(response []NilInt32, w return nil } -func encodeTestResponseIntegerInt32NullableArrayArrayResponse(response [][]NilInt32, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint32NullableArrayArrayResponse(response [][]NilUint32, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6176,20 +6912,20 @@ func encodeTestResponseIntegerInt32NullableArrayArrayResponse(response [][]NilIn return nil } -func encodeTestResponseIntegerInt64Response(response int64, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint64Response(response uint64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) e := jx.GetEncoder() - e.Int64(response) + e.UInt64(response) if _, err := e.WriteTo(w); err != nil { return errors.Wrap(err, "write") } return nil } -func encodeTestResponseIntegerInt64ArrayResponse(response []int64, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint64ArrayResponse(response []uint64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6197,7 +6933,7 @@ func encodeTestResponseIntegerInt64ArrayResponse(response []int64, w http.Respon e.ArrStart() for _, elem := range response { - e.Int64(elem) + e.UInt64(elem) } e.ArrEnd() if _, err := e.WriteTo(w); err != nil { @@ -6206,7 +6942,7 @@ func encodeTestResponseIntegerInt64ArrayResponse(response []int64, w http.Respon return nil } -func encodeTestResponseIntegerInt64ArrayArrayResponse(response [][]int64, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint64ArrayArrayResponse(response [][]uint64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6216,7 +6952,7 @@ func encodeTestResponseIntegerInt64ArrayArrayResponse(response [][]int64, w http for _, elem := range response { e.ArrStart() for _, elem := range elem { - e.Int64(elem) + e.UInt64(elem) } e.ArrEnd() } @@ -6227,7 +6963,7 @@ func encodeTestResponseIntegerInt64ArrayArrayResponse(response [][]int64, w http return nil } -func encodeTestResponseIntegerInt64NullableResponse(response NilInt64, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint64NullableResponse(response NilUint64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6240,7 +6976,7 @@ func encodeTestResponseIntegerInt64NullableResponse(response NilInt64, w http.Re return nil } -func encodeTestResponseIntegerInt64NullableArrayResponse(response []NilInt64, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint64NullableArrayResponse(response []NilUint64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6257,7 +6993,7 @@ func encodeTestResponseIntegerInt64NullableArrayResponse(response []NilInt64, w return nil } -func encodeTestResponseIntegerInt64NullableArrayArrayResponse(response [][]NilInt64, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUint64NullableArrayArrayResponse(response [][]NilUint64, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6278,7 +7014,45 @@ func encodeTestResponseIntegerInt64NullableArrayArrayResponse(response [][]NilIn return nil } -func encodeTestResponseIntegerNullableResponse(response NilInt, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUintArrayResponse(response []uint, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + e.ArrStart() + for _, elem := range response { + e.UInt(elem) + } + e.ArrEnd() + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestResponseIntegerUintArrayArrayResponse(response [][]uint, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + e := jx.GetEncoder() + + e.ArrStart() + for _, elem := range response { + e.ArrStart() + for _, elem := range elem { + e.UInt(elem) + } + e.ArrEnd() + } + e.ArrEnd() + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + return nil + +} +func encodeTestResponseIntegerUintNullableResponse(response NilUint, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6291,7 +7065,7 @@ func encodeTestResponseIntegerNullableResponse(response NilInt, w http.ResponseW return nil } -func encodeTestResponseIntegerNullableArrayResponse(response []NilInt, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUintNullableArrayResponse(response []NilUint, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) @@ -6308,7 +7082,7 @@ func encodeTestResponseIntegerNullableArrayResponse(response []NilInt, w http.Re return nil } -func encodeTestResponseIntegerNullableArrayArrayResponse(response [][]NilInt, w http.ResponseWriter, span trace.Span) error { +func encodeTestResponseIntegerUintNullableArrayArrayResponse(response [][]NilUint, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json") w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) diff --git a/examples/ex_test_format/oas_router_gen.go b/examples/ex_test_format/oas_router_gen.go index 4fe038a84..91b699188 100644 --- a/examples/ex_test_format/oas_router_gen.go +++ b/examples/ex_test_format/oas_router_gen.go @@ -641,201 +641,121 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'u': // Prefix: "unix" - if l := len("unix"); len(elem) >= l && elem[0:l] == "unix" { + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestIntegerUintRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestIntegerUint32Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMicroRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMicroArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + switch r.Method { + case "POST": + s.handleTestRequestIntegerUint32ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMicroArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestIntegerUnixMicroNullableRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint32ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMicroNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMicroNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMilliRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestIntegerUint32NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -844,7 +764,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestIntegerUnixMilliArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -863,75 +783,19 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestIntegerUnixMilliArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMilliNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMilliNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixMilliNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break @@ -940,7 +804,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestIntegerUnixNanoRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint64Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -969,7 +833,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestIntegerUnixNanoArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -988,7 +852,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestIntegerUnixNanoArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint64ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1006,7 +870,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestIntegerUnixNanoNullableRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1024,7 +888,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestIntegerUnixNanoNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint64NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1043,7 +907,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestIntegerUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUint64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1054,74 +918,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixSecondsRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestIntegerUintArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestIntegerUnixSecondsArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUintArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixSecondsArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUintNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -1130,7 +994,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestIntegerUnixSecondsNullableRequest([0]string{}, w, r) + s.handleTestRequestIntegerUintNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1146,434 +1010,186 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestIntegerUnixSecondsNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUintNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestIntegerUnixNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestIntegerUnixNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixMicroRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - } - } - case 'n': // Prefix: "nu" - if l := len("nu"); len(elem) >= l && elem[0:l] == "nu" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'l': // Prefix: "ll" - if l := len("ll"); len(elem) >= l && elem[0:l] == "ll" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNullRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMicroArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMicroArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNullArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMicroNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNullArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNullNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNullNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNullNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'm': // Prefix: "mber" - if l := len("mber"); len(elem) >= l && elem[0:l] == "mber" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'd': // Prefix: "double" - if l := len("double"); len(elem) >= l && elem[0:l] == "double" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberDoubleRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMicroNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberDoubleArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMicroNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberDoubleArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return + } + } + } } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberDoubleNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break @@ -1582,7 +1198,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestNumberDoubleNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixMilliRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1590,59 +1206,115 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberDoubleNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break } - return - } - } - } - } - } - case 'f': // Prefix: "float" - if l := len("float"); len(elem) >= l && elem[0:l] == "float" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMilliArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberFloatRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMilliArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMilliNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMilliNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixMilliNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + } + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break @@ -1651,7 +1323,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestNumberFloatArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixNanoRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1659,27 +1331,114 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberFloatArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break } - return + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixNanoArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixNanoArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixNanoNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixNanoNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break @@ -1688,7 +1447,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestNumberFloatNullableRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixSecondsRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1696,143 +1455,56 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberFloatNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestNumberFloatNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixSecondsArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberInt32Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberInt32ArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixSecondsArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberInt32ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberInt32NullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -1841,7 +1513,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestNumberInt32NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixSecondsNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1857,88 +1529,107 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestNumberInt32NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixSecondsNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberInt64Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestNumberInt64ArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberInt64ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestIntegerUnixNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -1947,7 +1638,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestNumberInt64NullableRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -1963,174 +1654,45 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestNumberInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestIntegerUnixNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberInt64NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + } + } + case 'n': // Prefix: "nu" + if l := len("nu"); len(elem) >= l && elem[0:l] == "nu" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestNumberNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestNumberNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - } - case 'r': // Prefix: "required_" - if l := len("required_"); len(elem) >= l && elem[0:l] == "required_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'A': // Prefix: "Any" - if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredAnyRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - case 'E': // Prefix: "EmptyStruct" - if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredEmptyStructRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - case 'F': // Prefix: "FormatTest" - if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredFormatTestRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - case 'b': // Prefix: "boolean" - if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'l': // Prefix: "ll" + if l := len("ll"); len(elem) >= l && elem[0:l] == "ll" { + elem = elem[l:] + } else { + break + } if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredBooleanRequest([0]string{}, w, r) + s.handleTestRequestNullRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2159,7 +1721,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredBooleanArrayRequest([0]string{}, w, r) + s.handleTestRequestNullArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2178,7 +1740,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredBooleanArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestNullArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2196,7 +1758,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredBooleanNullableRequest([0]string{}, w, r) + s.handleTestRequestNullNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2214,7 +1776,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredBooleanNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestNullNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2233,7 +1795,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredBooleanNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestNullNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2244,8 +1806,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'i': // Prefix: "integer" - if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { + case 'm': // Prefix: "mber" + if l := len("mber"); len(elem) >= l && elem[0:l] == "mber" { elem = elem[l:] } else { break @@ -2254,7 +1816,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerRequest([0]string{}, w, r) + s.handleTestRequestNumberRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2283,7 +1845,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2302,7 +1864,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2310,85 +1872,92 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + case 'd': // Prefix: "double" + if l := len("double"); len(elem) >= l && elem[0:l] == "double" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestNumberDoubleRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerInt32Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestNumberDoubleArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt32ArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberDoubleArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerInt32ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberDoubleNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -2397,7 +1966,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt32NullableRequest([0]string{}, w, r) + s.handleTestRequestNumberDoubleNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2413,49 +1982,166 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt32NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberDoubleNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { - elem = elem[l:] - } else { - break + } + case 'f': // Prefix: "float" + if l := len("float"); len(elem) >= l && elem[0:l] == "float" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberFloatRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerInt64Request([0]string{}, w, r) + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberFloatArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestNumberFloatArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberFloatNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberFloatNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestNumberFloatNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberInt32Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2484,7 +2170,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt64ArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberInt32ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2503,7 +2189,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt64ArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberInt32ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2521,7 +2207,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt64NullableRequest([0]string{}, w, r) + s.handleTestRequestNumberInt32NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2539,7 +2225,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberInt32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2558,7 +2244,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2569,27 +2255,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break @@ -2598,7 +2265,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestNumberInt64Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2606,57 +2273,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - case 'u': // Prefix: "unix" - if l := len("unix"); len(elem) >= l && elem[0:l] == "unix" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break @@ -2666,8 +2284,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -2676,7 +2294,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixMicroRequest([0]string{}, w, r) + s.handleTestRequestNumberInt64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2684,123 +2302,36 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestNumberInt64ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMicroArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMicroNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { - elem = elem[l:] - } else { - break - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixMilliRequest([0]string{}, w, r) + s.handleTestRequestNumberInt64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -2808,305 +2339,458 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMilliArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + switch r.Method { + case "POST": + s.handleTestRequestNumberInt64NullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixMilliNullableRequest([0]string{}, w, r) + s.handleTestRequestNumberInt64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + } + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestNumberNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixNanoRequest([0]string{}, w, r) + s.handleTestRequestNumberNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + } + } + } + } + } + case 'r': // Prefix: "required_" + if l := len("required_"); len(elem) >= l && elem[0:l] == "required_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'A': // Prefix: "Any" + if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixNanoArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredAnyRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + case 'E': // Prefix: "EmptyStruct" + if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredEmptyStructRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + return + } + case 'F': // Prefix: "FormatTest" + if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixNanoNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredFormatTestRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + case 'b': // Prefix: "boolean" + if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredBooleanRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredBooleanArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredBooleanArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredBooleanNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredBooleanNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixSecondsRequest([0]string{}, w, r) + s.handleTestRequestRequiredBooleanNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + } + } + } + } + case 'i': // Prefix: "integer" + if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixSecondsArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerInt32Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerInt32ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerInt32ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } + + return } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerInt32NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -3115,7 +2799,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixSecondsNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerInt32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3131,107 +2815,88 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerInt64Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerInt64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredIntegerUnixNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerInt64ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -3240,7 +2905,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerInt64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3256,64 +2921,59 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerInt64NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - } - } - case 'n': // Prefix: "nu" - if l := len("nu"); len(elem) >= l && elem[0:l] == "nu" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'l': // Prefix: "ll" - if l := len("ll"); len(elem) >= l && elem[0:l] == "ll" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerInt64NullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNullRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return + } + } + } + } + } } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -3322,7 +2982,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNullArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3341,92 +3001,17 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNullArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNullNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNullNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredNullNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } - } - case 'm': // Prefix: "mber" - if l := len("mber"); len(elem) >= l && elem[0:l] == "mber" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { elem = elem[l:] } else { break @@ -3436,8 +3021,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { elem = elem[l:] } else { break @@ -3446,7 +3031,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUintRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3454,111 +3039,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNumberArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint32Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'd': // Prefix: "double" - if l := len("double"); len(elem) >= l && elem[0:l] == "double" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberDoubleRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberDoubleArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNumberDoubleArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint32ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberDoubleNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUint32ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -3567,7 +3115,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberDoubleNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint32NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3583,157 +3131,40 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - case 'f': // Prefix: "float" - if l := len("float"); len(elem) >= l && elem[0:l] == "float" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberFloatRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberFloatArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberFloatArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberFloatNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberFloatNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUint32NullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberFloatNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return } - - return } } } } - } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break @@ -3742,7 +3173,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt32Request([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint64Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3771,7 +3202,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt32ArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3790,7 +3221,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt32ArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint64ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3808,7 +3239,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt32NullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3826,7 +3257,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt32NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint64NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3845,7 +3276,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt32NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUint64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3856,74 +3287,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberInt64Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUintArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt64ArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUintArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberInt64ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUintNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -3932,7 +3363,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt64NullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUintNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3948,41 +3379,22 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredNumberInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUintNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberInt64NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { elem = elem[l:] } else { break @@ -3991,7 +3403,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredNumberNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -3999,144 +3411,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredNumberNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - } - case 's': // Prefix: "string" - if l := len("string"); len(elem) >= l && elem[0:l] == "string" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'b': // Prefix: "b" - if l := len("b"); len(elem) >= l && elem[0:l] == "b" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'i': // Prefix: "inary" - if l := len("inary"); len(elem) >= l && elem[0:l] == "inary" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringBinaryRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break @@ -4146,63 +3422,19 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringBinaryArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringBinaryArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringBinaryNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break @@ -4211,7 +3443,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringBinaryNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixMicroRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4219,96 +3451,239 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringBinaryNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break } - return - } - } - } - } - } - case 'y': // Prefix: "yte" - if l := len("yte"); len(elem) >= l && elem[0:l] == "yte" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMicroArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringByteRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMicroArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringByteArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMicroNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMicroNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMicroNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringByteArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixMilliRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMilliArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMilliArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMilliNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMilliNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixMilliNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break @@ -4317,7 +3692,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringByteNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixNanoRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4325,162 +3700,180 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringByteNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringByteNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixNanoArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - } - case 'd': // Prefix: "d" - if l := len("d"); len(elem) >= l && elem[0:l] == "d" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "ate" - if l := len("ate"); len(elem) >= l && elem[0:l] == "ate" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDateRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixNanoArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '-': // Prefix: "-time" - if l := len("-time"); len(elem) >= l && elem[0:l] == "-time" { - elem = elem[l:] - } else { - break - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDateTimeRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixNanoNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixNanoNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixSecondsRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDateTimeArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateTimeArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixSecondsArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDateTimeNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixSecondsArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -4489,7 +3882,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateTimeNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixSecondsNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4505,16 +3898,35 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateTimeNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixSecondsNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredIntegerUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } @@ -4540,7 +3952,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4559,7 +3971,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4577,7 +3989,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4595,7 +4007,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4614,7 +4026,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringDateNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredIntegerUnixNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4625,8 +4037,51 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'u': // Prefix: "uration" - if l := len("uration"); len(elem) >= l && elem[0:l] == "uration" { + } + } + } + case 'n': // Prefix: "nu" + if l := len("nu"); len(elem) >= l && elem[0:l] == "nu" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'l': // Prefix: "ll" + if l := len("ll"); len(elem) >= l && elem[0:l] == "ll" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNullRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -4635,7 +4090,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringDurationRequest([0]string{}, w, r) + s.handleTestRequestRequiredNullArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4643,199 +4098,180 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredNullArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDurationArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNullNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDurationArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNullNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringDurationNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredNullNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDurationNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringDurationNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } } } } - case 'e': // Prefix: "email" - if l := len("email"); len(elem) >= l && elem[0:l] == "email" { + } + case 'm': // Prefix: "mber" + if l := len("mber"); len(elem) >= l && elem[0:l] == "mber" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringEmailRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringEmailArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringEmailArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'd': // Prefix: "double" + if l := len("double"); len(elem) >= l && elem[0:l] == "double" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberDoubleRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringEmailNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -4844,7 +4280,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringEmailNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberDoubleArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4863,7 +4299,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringEmailNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberDoubleArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4871,95 +4307,95 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } } - } - } - } - case 'h': // Prefix: "hostname" - if l := len("hostname"); len(elem) >= l && elem[0:l] == "hostname" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringHostnameRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringHostnameArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringHostnameArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberDoubleNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringHostnameNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberDoubleNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberDoubleNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } + } + } + case 'f': // Prefix: "float" + if l := len("float"); len(elem) >= l && elem[0:l] == "float" { + elem = elem[l:] + } else { + break + } - return + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberFloatRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -4968,7 +4404,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringHostnameNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberFloatArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -4987,30 +4423,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringHostnameNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberFloatArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberFloatNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberFloatNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberFloatNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } - } - case 'i': // Prefix: "i" - if l := len("i"); len(elem) >= l && elem[0:l] == "i" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'n': // Prefix: "nt" - if l := len("nt"); len(elem) >= l && elem[0:l] == "nt" { + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { elem = elem[l:] } else { break @@ -5030,7 +4510,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt32Request([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt32Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5059,7 +4539,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt32ArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt32ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5078,7 +4558,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt32ArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt32ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5096,7 +4576,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt32NullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt32NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5114,7 +4594,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt32NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5133,7 +4613,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt32NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5154,7 +4634,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt64Request([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt64Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5183,7 +4663,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt64ArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5202,7 +4682,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt64ArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt64ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5220,7 +4700,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt64NullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5238,7 +4718,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt64NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5257,7 +4737,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringInt64NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberInt64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5269,8 +4749,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'p': // Prefix: "p" - if l := len("p"); len(elem) >= l && elem[0:l] == "p" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -5279,7 +4759,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringIPRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5287,65 +4767,164 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredNumberNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringIPArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredNumberNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + } + case 's': // Prefix: "string" + if l := len("string"); len(elem) >= l && elem[0:l] == "string" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIPArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIPNullableRequest([0]string{}, w, r) + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'b': // Prefix: "b" + if l := len("b"); len(elem) >= l && elem[0:l] == "b" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'i': // Prefix: "inary" + if l := len("inary"); len(elem) >= l && elem[0:l] == "inary" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringBinaryRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringBinaryArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5361,9 +4940,46 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringIPNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringBinaryArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringBinaryNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringBinaryNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5382,7 +4998,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringIPNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringBinaryNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5392,8 +5008,27 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'v': // Prefix: "v" - if l := len("v"); len(elem) >= l && elem[0:l] == "v" { + } + case 'y': // Prefix: "yte" + if l := len("yte"); len(elem) >= l && elem[0:l] == "yte" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringByteRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break @@ -5403,8 +5038,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case '4': // Prefix: "4" - if l := len("4"); len(elem) >= l && elem[0:l] == "4" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -5413,7 +5048,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringIpv4Request([0]string{}, w, r) + s.handleTestRequestRequiredStringByteArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5421,180 +5056,199 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringByteArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIpv4ArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringByteNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIpv4ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringByteNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringIpv4NullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringByteNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + } + case 'd': // Prefix: "d" + if l := len("d"); len(elem) >= l && elem[0:l] == "d" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIpv4NullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "ate" + if l := len("ate"); len(elem) >= l && elem[0:l] == "ate" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIpv4NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '-': // Prefix: "-time" + if l := len("-time"); len(elem) >= l && elem[0:l] == "-time" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateTimeRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case '6': // Prefix: "6" - if l := len("6"); len(elem) >= l && elem[0:l] == "6" { + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIpv6Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateTimeArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringIpv6ArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringDateTimeArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIpv6ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateTimeNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -5603,7 +5257,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringIpv6NullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringDateTimeNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5619,114 +5273,268 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringIpv6NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringDateTimeNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringIpv6NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } - } - } - case 'p': // Prefix: "password" - if l := len("password"); len(elem) >= l && elem[0:l] == "password" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringPasswordRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDateNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'u': // Prefix: "uration" + if l := len("uration"); len(elem) >= l && elem[0:l] == "uration" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDurationRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDurationArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDurationArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDurationNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDurationNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringDurationNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + } + case 'e': // Prefix: "email" + if l := len("email"); len(elem) >= l && elem[0:l] == "email" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringEmailRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } switch elem[0] { case '_': // Prefix: "_" if l := len("_"); len(elem) >= l && elem[0:l] == "_" { @@ -5749,7 +5557,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringPasswordArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringEmailArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5768,7 +5576,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringPasswordArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringEmailArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5786,7 +5594,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringPasswordNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringEmailNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5804,7 +5612,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringPasswordNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringEmailNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5823,7 +5631,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringPasswordNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringEmailNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5834,8 +5642,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 't': // Prefix: "time" - if l := len("time"); len(elem) >= l && elem[0:l] == "time" { + case 'h': // Prefix: "hostname" + if l := len("hostname"); len(elem) >= l && elem[0:l] == "hostname" { elem = elem[l:] } else { break @@ -5844,7 +5652,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringTimeRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringHostnameRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5873,7 +5681,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringTimeArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringHostnameArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5892,7 +5700,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringTimeArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringHostnameArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5910,7 +5718,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringTimeNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringHostnameNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5928,7 +5736,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringTimeNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringHostnameNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5947,7 +5755,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringTimeNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringHostnameNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -5958,8 +5766,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'u': // Prefix: "u" - if l := len("u"); len(elem) >= l && elem[0:l] == "u" { + case 'i': // Prefix: "i" + if l := len("i"); len(elem) >= l && elem[0:l] == "i" { elem = elem[l:] } else { break @@ -5969,37 +5777,37 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'n': // Prefix: "nix" - if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { + case 'n': // Prefix: "nt" + if l := len("nt"); len(elem) >= l && elem[0:l] == "nt" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt32Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break @@ -6009,8 +5817,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -6019,7 +5827,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixMicroRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringInt32ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6027,114 +5835,151 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt32ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMicroArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt32NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMicroArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt32NullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixMicroNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMicroNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt64Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt64ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt64ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } + + return } } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -6143,7 +5988,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixMilliRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringInt64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6151,115 +5996,183 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringInt64NullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixMilliArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringInt64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMilliArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + } + } + } + } + case 'p': // Prefix: "p" + if l := len("p"); len(elem) >= l && elem[0:l] == "p" { + elem = elem[l:] + } else { + break + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringIPRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMilliNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMilliNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringIPArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringIPArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringIPNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringIPNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringIPNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } + + return } } } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + } + case 'v': // Prefix: "v" + if l := len("v"); len(elem) >= l && elem[0:l] == "v" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '4': // Prefix: "4" + if l := len("4"); len(elem) >= l && elem[0:l] == "4" { elem = elem[l:] } else { break @@ -6268,7 +6181,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNanoRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv4Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6297,7 +6210,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNanoArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv4ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6316,7 +6229,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNanoArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv4ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6334,7 +6247,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNanoNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv4NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6352,7 +6265,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNanoNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv4NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6371,7 +6284,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv4NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6382,8 +6295,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + case '6': // Prefix: "6" + if l := len("6"); len(elem) >= l && elem[0:l] == "6" { elem = elem[l:] } else { break @@ -6392,7 +6305,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixSecondsRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv6Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6421,7 +6334,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixSecondsArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv6ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6440,7 +6353,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixSecondsArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv6ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6458,7 +6371,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixSecondsNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv6NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6476,7 +6389,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixSecondsNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv6NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6495,7 +6408,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringIpv6NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6507,56 +6420,150 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + case 'p': // Prefix: "password" + if l := len("password"); len(elem) >= l && elem[0:l] == "password" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringPasswordRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringPasswordArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringPasswordArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringPasswordNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -6565,7 +6572,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringPasswordNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6581,106 +6588,106 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUnixNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringPasswordNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUnixNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } - case 'r': // Prefix: "ri" - if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { + } + case 't': // Prefix: "time" + if l := len("time"); len(elem) >= l && elem[0:l] == "time" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringTimeRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringURIRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringTimeArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringURIArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringTimeArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringURIArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringTimeNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -6689,7 +6696,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringURINullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringTimeNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6705,58 +6712,51 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringURINullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringTimeNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringURINullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } - case 'u': // Prefix: "uid" - if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUUIDRequest([0]string{}, w, r) - default: + } + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixRequest([0]string{}, w, r) + default: s.notAllowed(w, r, "POST") } return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break @@ -6766,63 +6766,143 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUUIDArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestRequiredStringUUIDArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUnixMicroRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUUIDNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMicroArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMicroArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMicroNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMicroNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break @@ -6831,7 +6911,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestRequiredStringUUIDNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUnixMilliRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -6839,195 +6919,115 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestRequiredStringUUIDNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break } - return - } - } - } - } - } - } - } - } - } - case 's': // Prefix: "string" - if l := len("string"); len(elem) >= l && elem[0:l] == "string" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMilliArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMilliArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'b': // Prefix: "b" - if l := len("b"); len(elem) >= l && elem[0:l] == "b" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'i': // Prefix: "inary" - if l := len("inary"); len(elem) >= l && elem[0:l] == "inary" { - elem = elem[l:] - } else { - break - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringBinaryRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMilliNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMilliNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringBinaryArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringBinaryArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return + } + } + } + } } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringBinaryNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break @@ -7036,7 +7036,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringBinaryNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUnixNanoRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7044,114 +7044,250 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringBinaryNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break } - return - } - } - } - } - } - case 'y': // Prefix: "yte" - if l := len("yte"); len(elem) >= l && elem[0:l] == "yte" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNanoArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringByteRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNanoArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringByteArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNanoNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNanoNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringByteArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUnixSecondsRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixSecondsArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixSecondsArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixSecondsNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixSecondsNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringByteNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -7160,7 +7296,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringByteNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUnixArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7179,7 +7315,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringByteNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUnixArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7187,41 +7323,66 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } } - } - } - } - } - case 'd': // Prefix: "d" - if l := len("d"); len(elem) >= l && elem[0:l] == "d" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "ate" - if l := len("ate"); len(elem) >= l && elem[0:l] == "ate" { - elem = elem[l:] - } else { - break - } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringDateRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '-': // Prefix: "-time" - if l := len("-time"); len(elem) >= l && elem[0:l] == "-time" { + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUnixNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'r': // Prefix: "ri" + if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { elem = elem[l:] } else { break @@ -7230,7 +7391,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDateTimeRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringURIRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7259,7 +7420,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDateTimeArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringURIArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7278,7 +7439,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringDateTimeArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringURIArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7296,7 +7457,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDateTimeNullableRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringURINullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7314,7 +7475,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDateTimeNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringURINullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7333,7 +7494,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringDateTimeNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringURINullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7344,74 +7505,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'u': // Prefix: "uid" + if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUUIDRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringDateArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringDateArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUUIDArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringDateNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUUIDArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -7420,7 +7581,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDateNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUUIDNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7436,31 +7597,130 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringDateNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestRequiredStringUUIDNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringUUIDNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } } - case 'u': // Prefix: "uration" - if l := len("uration"); len(elem) >= l && elem[0:l] == "uration" { + } + } + } + case 's': // Prefix: "string" + if l := len("string"); len(elem) >= l && elem[0:l] == "string" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringDurationRequest([0]string{}, w, r) + s.handleTestRequestStringArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'b': // Prefix: "b" + if l := len("b"); len(elem) >= l && elem[0:l] == "b" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'i': // Prefix: "inary" + if l := len("inary"); len(elem) >= l && elem[0:l] == "inary" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringBinaryRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7489,7 +7749,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDurationArrayRequest([0]string{}, w, r) + s.handleTestRequestStringBinaryArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7508,7 +7768,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringDurationArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringBinaryArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7526,7 +7786,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDurationNullableRequest([0]string{}, w, r) + s.handleTestRequestStringBinaryNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7544,7 +7804,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringDurationNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringBinaryNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7563,7 +7823,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringDurationNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringBinaryNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7574,93 +7834,37 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - } - case 'e': // Prefix: "email" - if l := len("email"); len(elem) >= l && elem[0:l] == "email" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringEmailRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'y': // Prefix: "yte" + if l := len("yte"); len(elem) >= l && elem[0:l] == "yte" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestStringByteRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringEmailArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringEmailArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringEmailNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -7669,7 +7873,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringEmailNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringByteArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7688,7 +7892,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringEmailNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringByteArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7696,95 +7900,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } } - } - } - } - case 'h': // Prefix: "hostname" - if l := len("hostname"); len(elem) >= l && elem[0:l] == "hostname" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringHostnameRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringHostnameArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringHostnameArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringHostnameNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -7793,7 +7910,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringHostnameNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringByteNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7809,22 +7926,41 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringHostnameNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringByteNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringByteNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } } - case 'i': // Prefix: "i" - if l := len("i"); len(elem) >= l && elem[0:l] == "i" { + case 'd': // Prefix: "d" + if l := len("d"); len(elem) >= l && elem[0:l] == "d" { elem = elem[l:] } else { break @@ -7834,19 +7970,26 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'n': // Prefix: "nt" - if l := len("nt"); len(elem) >= l && elem[0:l] == "nt" { + case 'a': // Prefix: "ate" + if l := len("ate"); len(elem) >= l && elem[0:l] == "ate" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestStringDateRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + case '-': // Prefix: "-time" + if l := len("-time"); len(elem) >= l && elem[0:l] == "-time" { elem = elem[l:] } else { break @@ -7855,7 +7998,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringInt32Request([0]string{}, w, r) + s.handleTestRequestStringDateTimeRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7884,7 +8027,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringInt32ArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDateTimeArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7903,7 +8046,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringInt32ArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDateTimeArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7921,7 +8064,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringInt32NullableRequest([0]string{}, w, r) + s.handleTestRequestStringDateTimeNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7939,7 +8082,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringInt32NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDateTimeNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7958,7 +8101,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringInt32NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDateTimeNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -7969,74 +8112,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringInt64Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + switch r.Method { + case "POST": + s.handleTestRequestStringDateArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringInt64ArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDateArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringInt64ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringDateNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -8045,7 +8188,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringInt64NullableRequest([0]string{}, w, r) + s.handleTestRequestStringDateNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8061,41 +8204,22 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDateNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringInt64NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case 'p': // Prefix: "p" - if l := len("p"); len(elem) >= l && elem[0:l] == "p" { + case 'u': // Prefix: "uration" + if l := len("uration"); len(elem) >= l && elem[0:l] == "uration" { elem = elem[l:] } else { break @@ -8104,7 +8228,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringIPRequest([0]string{}, w, r) + s.handleTestRequestStringDurationRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8133,7 +8257,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringIPArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDurationArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8152,7 +8276,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringIPArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDurationArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8170,7 +8294,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringIPNullableRequest([0]string{}, w, r) + s.handleTestRequestStringDurationNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8188,7 +8312,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringIPNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDurationNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8207,7 +8331,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringIPNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringDurationNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8217,19 +8341,94 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'v': // Prefix: "v" - if l := len("v"); len(elem) >= l && elem[0:l] == "v" { + } + } + case 'e': // Prefix: "email" + if l := len("email"); len(elem) >= l && elem[0:l] == "email" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringEmailRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringEmailArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringEmailArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { break } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringEmailNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } switch elem[0] { - case '4': // Prefix: "4" - if l := len("4"); len(elem) >= l && elem[0:l] == "4" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -8238,7 +8437,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringIpv4Request([0]string{}, w, r) + s.handleTestRequestStringEmailNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8246,114 +8445,114 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringEmailNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringIpv4ArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + } + } + } + case 'h': // Prefix: "hostname" + if l := len("hostname"); len(elem) >= l && elem[0:l] == "hostname" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringHostnameRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringIpv4ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringIpv4NullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringHostnameArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringIpv4NullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringHostnameArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringIpv4NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringHostnameNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case '6': // Prefix: "6" - if l := len("6"); len(elem) >= l && elem[0:l] == "6" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -8362,7 +8561,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringIpv6Request([0]string{}, w, r) + s.handleTestRequestStringHostnameNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8370,56 +8569,136 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringHostnameNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'i': // Prefix: "i" + if l := len("i"); len(elem) >= l && elem[0:l] == "i" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'n': // Prefix: "nt" + if l := len("nt"); len(elem) >= l && elem[0:l] == "nt" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringInt32Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { break } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringInt32ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringIpv6ArrayRequest([0]string{}, w, r) + s.handleTestRequestStringInt32ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringIpv6ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringInt32NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -8428,7 +8707,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringIpv6NullableRequest([0]string{}, w, r) + s.handleTestRequestStringInt32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8444,183 +8723,213 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringIpv6NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringIpv6NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringInt64Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - case 'p': // Prefix: "password" - if l := len("password"); len(elem) >= l && elem[0:l] == "password" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringPasswordRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringInt64ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringInt64ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringInt64NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringInt64NullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringInt64NullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + } + case 'p': // Prefix: "p" + if l := len("p"); len(elem) >= l && elem[0:l] == "p" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestStringIPRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringPasswordArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringPasswordArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIPArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringPasswordNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringIPArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -8629,7 +8938,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringPasswordNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIPNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8645,106 +8954,50 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringPasswordNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIPNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - case 't': // Prefix: "time" - if l := len("time"); len(elem) >= l && elem[0:l] == "time" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringTimeRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringTimeArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringIPNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringTimeArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return + } } - - return } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case 'v': // Prefix: "v" + if l := len("v"); len(elem) >= l && elem[0:l] == "v" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringTimeNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '4': // Prefix: "4" + if l := len("4"); len(elem) >= l && elem[0:l] == "4" { elem = elem[l:] } else { break @@ -8753,7 +9006,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringTimeNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIpv4Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8761,147 +9014,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringTimeNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'u': // Prefix: "u" - if l := len("u"); len(elem) >= l && elem[0:l] == "u" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'n': // Prefix: "nix" - if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMicroRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestStringIpv4ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringUnixMicroArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIpv4ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMicroArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringIpv4NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -8910,7 +9090,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUnixMicroNullableRequest([0]string{}, w, r) + s.handleTestRequestStringIpv4NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -8926,165 +9106,22 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringUnixMicroNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIpv4NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMicroNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMilliRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMilliArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMilliArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMilliNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMilliNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixMilliNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + case '6': // Prefix: "6" + if l := len("6"); len(elem) >= l && elem[0:l] == "6" { elem = elem[l:] } else { break @@ -9093,7 +9130,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUnixNanoRequest([0]string{}, w, r) + s.handleTestRequestStringIpv6Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9122,7 +9159,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUnixNanoArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIpv6ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9141,7 +9178,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringUnixNanoArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIpv6ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9159,7 +9196,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUnixNanoNullableRequest([0]string{}, w, r) + s.handleTestRequestStringIpv6NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9177,7 +9214,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUnixNanoNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIpv6NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9196,7 +9233,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringIpv6NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9207,181 +9244,151 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { - elem = elem[l:] - } else { - break - } + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixSecondsRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixSecondsArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixSecondsArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixSecondsNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUnixSecondsNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + } + case 'p': // Prefix: "password" + if l := len("password"); len(elem) >= l && elem[0:l] == "password" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringPasswordRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } - } - } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestStringPasswordArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringUnixArrayRequest([0]string{}, w, r) + s.handleTestRequestStringPasswordArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringPasswordNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -9390,7 +9397,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUnixNullableRequest([0]string{}, w, r) + s.handleTestRequestStringPasswordNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9406,106 +9413,106 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringUnixNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringPasswordNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUnixNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } - case 'r': // Prefix: "ri" - if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { + } + case 't': // Prefix: "time" + if l := len("time"); len(elem) >= l && elem[0:l] == "time" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringTimeRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringURIRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestStringTimeArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringURIArrayRequest([0]string{}, w, r) + s.handleTestRequestStringTimeArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringURIArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringTimeNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -9514,7 +9521,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringURINullableRequest([0]string{}, w, r) + s.handleTestRequestStringTimeNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9530,40 +9537,33 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringURINullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringTimeNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringURINullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } - case 'u': // Prefix: "uid" - if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { + } + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { elem = elem[l:] } else { break @@ -9572,7 +9572,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUUIDRequest([0]string{}, w, r) + s.handleTestRequestStringUnixRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9580,8 +9580,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break @@ -9591,63 +9591,143 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUUIDArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestRequestStringUUIDArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUnixMicroRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestRequestStringUUIDNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMicroArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMicroArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMicroNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMicroNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMicroNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break @@ -9656,7 +9736,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestRequestStringUUIDNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUnixMilliRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -9664,366 +9744,239 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestRequestStringUUIDNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break } - return - } - } - } - } - } - } - } - } - } - case 's': // Prefix: "sponse_" - if l := len("sponse_"); len(elem) >= l && elem[0:l] == "sponse_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMilliArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'A': // Prefix: "Any" - if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseAnyRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - case 'E': // Prefix: "EmptyStruct" - if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMilliArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseEmptyStructRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - case 'F': // Prefix: "FormatTest" - if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMilliNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseFormatTestRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - case 'b': // Prefix: "boolean" - if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMilliNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseBooleanRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixMilliNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + return + } + } + } + } + } + } + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseBooleanArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixNanoRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseBooleanArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixNanoArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseBooleanNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixNanoArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseBooleanNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseBooleanNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'i': // Prefix: "integer" - if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { - elem = elem[l:] - } else { - break - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerInt32Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixNanoNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixNanoNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerInt32ArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerInt32ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return + } + } } - - return } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break @@ -10032,7 +9985,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerInt32NullableRequest([0]string{}, w, r) + s.handleTestRequestStringUnixSecondsRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10040,64 +9993,113 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerInt32NullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerInt32NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUnixSecondsArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerInt64Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixSecondsArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixSecondsNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUnixSecondsNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + } case '_': // Prefix: "_" if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] @@ -10119,7 +10121,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerInt64ArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUnixArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10138,7 +10140,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerInt64ArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUnixArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10156,7 +10158,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerInt64NullableRequest([0]string{}, w, r) + s.handleTestRequestStringUnixNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10174,7 +10176,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUnixNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10193,7 +10195,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerInt64NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUnixNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10204,27 +10206,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'r': // Prefix: "ri" + if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { elem = elem[l:] } else { break @@ -10233,7 +10216,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerNullableArrayRequest([0]string{}, w, r) + s.handleTestRequestStringURIRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10241,57 +10224,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - case 'u': // Prefix: "unix" - if l := len("unix"); len(elem) >= l && elem[0:l] == "unix" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break @@ -10301,8 +10235,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -10311,7 +10245,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerUnixMicroRequest([0]string{}, w, r) + s.handleTestRequestStringURIArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10319,114 +10253,114 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringURIArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMicroArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringURINullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMicroArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringURINullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerUnixMicroNullableRequest([0]string{}, w, r) + s.handleTestRequestStringURINullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMicroNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + } + } + } + case 'u': // Prefix: "uid" + if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringUUIDRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMicroNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } - } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -10435,7 +10369,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerUnixMilliRequest([0]string{}, w, r) + s.handleTestRequestStringUUIDArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10443,144 +10377,45 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMilliArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMilliArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMilliNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + // Leaf node. + switch r.Method { + case "POST": + s.handleTestRequestStringUUIDArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMilliNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixMilliNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - return - } - } - } + return } } - } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixNanoRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestRequestStringUUIDNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -10589,7 +10424,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerUnixNanoArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUUIDNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10608,7 +10443,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerUnixNanoArrayArrayRequest([0]string{}, w, r) + s.handleTestRequestStringUUIDNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10616,141 +10451,374 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + } + } + } + } + } + } + } + case 's': // Prefix: "sponse_" + if l := len("sponse_"); len(elem) >= l && elem[0:l] == "sponse_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixNanoNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'A': // Prefix: "Any" + if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseAnyRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixNanoNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + case 'E': // Prefix: "EmptyStruct" + if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseEmptyStructRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixNanoNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + case 'F': // Prefix: "FormatTest" + if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseFormatTestRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + case 'b': // Prefix: "boolean" + if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseBooleanRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseBooleanArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseBooleanArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseBooleanNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseBooleanNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerUnixSecondsRequest([0]string{}, w, r) + s.handleTestResponseBooleanNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + } + } + } + } + case 'i': // Prefix: "integer" + if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixSecondsArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixSecondsArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerInt32Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerInt32ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerInt32ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerInt32NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break } if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerUnixSecondsNullableRequest([0]string{}, w, r) + s.handleTestResponseIntegerInt32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10766,107 +10834,88 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerUnixSecondsNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseIntegerInt64Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerUnixArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerInt64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseIntegerUnixNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerInt64ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -10875,7 +10924,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseIntegerUnixNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerInt64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10891,64 +10940,59 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseIntegerUnixNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerInt64NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerInt64NullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } } - } - } - case 'n': // Prefix: "nu" - if l := len("nu"); len(elem) >= l && elem[0:l] == "nu" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'l': // Prefix: "ll" - if l := len("ll"); len(elem) >= l && elem[0:l] == "ll" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNullRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseIntegerNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -10957,7 +11001,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNullArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -10976,92 +11020,17 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNullArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNullNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNullNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseNullNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } - } - case 'm': // Prefix: "mber" - if l := len("mber"); len(elem) >= l && elem[0:l] == "mber" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { elem = elem[l:] } else { break @@ -11071,8 +11040,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { elem = elem[l:] } else { break @@ -11081,7 +11050,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUintRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11089,111 +11058,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNumberArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint32Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'd': // Prefix: "double" - if l := len("double"); len(elem) >= l && elem[0:l] == "double" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberDoubleRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberDoubleArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNumberDoubleArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint32ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberDoubleNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUint32ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -11202,7 +11134,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberDoubleNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint32NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11218,166 +11150,49 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNumberDoubleNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUint32NullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } - } - case 'f': // Prefix: "float" - if l := len("float"); len(elem) >= l && elem[0:l] == "float" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberFloatRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberFloatArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseNumberFloatArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberFloatNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberFloatNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseNumberFloatNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { - elem = elem[l:] - } else { - break - } + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + elem = elem[l:] + } else { + break + } if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberInt32Request([0]string{}, w, r) + s.handleTestResponseIntegerUint64Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11406,7 +11221,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberInt32ArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11425,7 +11240,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNumberInt32ArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint64ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11443,7 +11258,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberInt32NullableRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11461,7 +11276,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberInt32NullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint64NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11480,7 +11295,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNumberInt32NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUint64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11491,74 +11306,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberInt64Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseIntegerUintArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNumberInt64ArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUintArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseNumberInt64ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUintNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -11567,7 +11382,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberInt64NullableRequest([0]string{}, w, r) + s.handleTestResponseIntegerUintNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11583,41 +11398,22 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseNumberInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUintNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseNumberInt64NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { elem = elem[l:] } else { break @@ -11626,7 +11422,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseNumberNullableRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11634,316 +11430,279 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseNumberNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseNumberNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + break + } + switch elem[0] { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + elem = elem[l:] + } else { + break } - return - } - } - } - } - } - } - case 's': // Prefix: "string" - if l := len("string"); len(elem) >= l && elem[0:l] == "string" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMicroRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMicroArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMicroArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - } - case 'b': // Prefix: "b" - if l := len("b"); len(elem) >= l && elem[0:l] == "b" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMicroNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'i': // Prefix: "inary" - if l := len("inary"); len(elem) >= l && elem[0:l] == "inary" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringBinaryRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMicroNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMicroNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringBinaryArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + return + } + } + } + } } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringBinaryArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixMilliRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringBinaryNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringBinaryNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { + if len(elem) == 0 { break } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringBinaryNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMilliArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - } - } - } - } - case 'y': // Prefix: "yte" - if l := len("yte"); len(elem) >= l && elem[0:l] == "yte" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMilliArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringByteRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMilliNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringByteArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMilliNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringByteArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixMilliNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return + return + } + } + } + } } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break @@ -11952,7 +11711,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringByteNullableRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixNanoRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -11960,162 +11719,180 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringByteNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringByteNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixNanoArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - } - } - } - } - case 'd': // Prefix: "d" - if l := len("d"); len(elem) >= l && elem[0:l] == "d" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "ate" - if l := len("ate"); len(elem) >= l && elem[0:l] == "ate" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixNanoArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringDateRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '-': // Prefix: "-time" - if l := len("-time"); len(elem) >= l && elem[0:l] == "-time" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixNanoNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringDateTimeRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixNanoNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixSecondsRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringDateTimeArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringDateTimeArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixSecondsArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringDateTimeNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixSecondsArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -12124,7 +11901,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringDateTimeNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixSecondsNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12140,16 +11917,35 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringDateTimeNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixSecondsNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } @@ -12175,7 +11971,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringDateArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12194,7 +11990,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringDateArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12212,7 +12008,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringDateNullableRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12230,7 +12026,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringDateNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12249,7 +12045,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringDateNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseIntegerUnixNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12260,8 +12056,51 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'u': // Prefix: "uration" - if l := len("uration"); len(elem) >= l && elem[0:l] == "uration" { + } + } + } + case 'n': // Prefix: "nu" + if l := len("nu"); len(elem) >= l && elem[0:l] == "nu" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'l': // Prefix: "ll" + if l := len("ll"); len(elem) >= l && elem[0:l] == "ll" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseNullRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -12270,7 +12109,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringDurationRequest([0]string{}, w, r) + s.handleTestResponseNullArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12278,28 +12117,189 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseNullArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseNullNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { break } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseNullNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringDurationArrayRequest([0]string{}, w, r) + s.handleTestResponseNullNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'm': // Prefix: "mber" + if l := len("mber"); len(elem) >= l && elem[0:l] == "mber" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseNumberRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseNumberArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseNumberArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'd': // Prefix: "double" + if l := len("double"); len(elem) >= l && elem[0:l] == "double" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseNumberDoubleRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseNumberDoubleArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12318,7 +12318,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringDurationArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberDoubleArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12336,7 +12336,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringDurationNullableRequest([0]string{}, w, r) + s.handleTestResponseNumberDoubleNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12354,7 +12354,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringDurationNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberDoubleNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12373,7 +12373,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringDurationNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberDoubleNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12384,93 +12384,74 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - } - case 'e': // Prefix: "email" - if l := len("email"); len(elem) >= l && elem[0:l] == "email" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringEmailRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'f': // Prefix: "float" + if l := len("float"); len(elem) >= l && elem[0:l] == "float" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseNumberFloatRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringEmailArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringEmailArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberFloatArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringEmailNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseNumberFloatArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -12479,7 +12460,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringEmailNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberFloatNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12495,161 +12476,44 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringEmailNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberFloatNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseNumberFloatNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } } } } - } - case 'h': // Prefix: "hostname" - if l := len("hostname"); len(elem) >= l && elem[0:l] == "hostname" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringHostnameRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringHostnameArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringHostnameArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringHostnameNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringHostnameNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringHostnameNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } - } - } - } - case 'i': // Prefix: "i" - if l := len("i"); len(elem) >= l && elem[0:l] == "i" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'n': // Prefix: "nt" - if l := len("nt"); len(elem) >= l && elem[0:l] == "nt" { - elem = elem[l:] - } else { - break - } + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + elem = elem[l:] + } else { + break + } if len(elem) == 0 { break @@ -12665,7 +12529,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt32Request([0]string{}, w, r) + s.handleTestResponseNumberInt32Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12694,7 +12558,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt32ArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt32ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12713,7 +12577,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringInt32ArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt32ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12731,7 +12595,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt32NullableRequest([0]string{}, w, r) + s.handleTestResponseNumberInt32NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12749,7 +12613,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt32NullableArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt32NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12768,7 +12632,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringInt32NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12789,7 +12653,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt64Request([0]string{}, w, r) + s.handleTestResponseNumberInt64Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12818,7 +12682,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt64ArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt64ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12837,7 +12701,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringInt64ArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt64ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12855,7 +12719,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt64NullableRequest([0]string{}, w, r) + s.handleTestResponseNumberInt64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12873,7 +12737,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringInt64NullableArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt64NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12892,7 +12756,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringInt64NullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberInt64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12904,8 +12768,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'p': // Prefix: "p" - if l := len("p"); len(elem) >= l && elem[0:l] == "p" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -12914,7 +12778,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringIPRequest([0]string{}, w, r) + s.handleTestResponseNumberNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -12922,83 +12786,219 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseNumberNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringIPArrayRequest([0]string{}, w, r) + s.handleTestResponseNumberNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + } + case 's': // Prefix: "string" + if l := len("string"); len(elem) >= l && elem[0:l] == "string" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringIPArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringIPNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'b': // Prefix: "b" + if l := len("b"); len(elem) >= l && elem[0:l] == "b" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'i': // Prefix: "inary" + if l := len("inary"); len(elem) >= l && elem[0:l] == "inary" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringBinaryRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringBinaryArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringIPNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringBinaryArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringBinaryNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringBinaryNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13017,7 +13017,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringIPNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringBinaryNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13027,8 +13027,27 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'v': // Prefix: "v" - if l := len("v"); len(elem) >= l && elem[0:l] == "v" { + } + case 'y': // Prefix: "yte" + if l := len("yte"); len(elem) >= l && elem[0:l] == "yte" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringByteRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break @@ -13038,8 +13057,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case '4': // Prefix: "4" - if l := len("4"); len(elem) >= l && elem[0:l] == "4" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -13048,7 +13067,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringIpv4Request([0]string{}, w, r) + s.handleTestResponseStringByteArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13056,180 +13075,199 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringByteArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringIpv4ArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringByteNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringIpv4ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringByteNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringIpv4NullableRequest([0]string{}, w, r) + s.handleTestResponseStringByteNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringIpv4NullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + } + } + } + } + case 'd': // Prefix: "d" + if l := len("d"); len(elem) >= l && elem[0:l] == "d" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "ate" + if l := len("ate"); len(elem) >= l && elem[0:l] == "ate" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringIpv4NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDateRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - } - } - } + return + } + switch elem[0] { + case '-': // Prefix: "-time" + if l := len("-time"); len(elem) >= l && elem[0:l] == "-time" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDateTimeRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case '6': // Prefix: "6" - if l := len("6"); len(elem) >= l && elem[0:l] == "6" { + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringIpv6Request([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseStringDateTimeArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringIpv6ArrayRequest([0]string{}, w, r) + s.handleTestResponseStringDateTimeArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringIpv6ArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDateTimeNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -13238,7 +13276,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringIpv6NullableRequest([0]string{}, w, r) + s.handleTestResponseStringDateTimeNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13254,114 +13292,268 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringIpv6NullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringDateTimeNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringIpv6NullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } - } - } - case 'p': // Prefix: "password" - if l := len("password"); len(elem) >= l && elem[0:l] == "password" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringPasswordRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDateArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringDateArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDateNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDateNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringDateNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'u': // Prefix: "uration" + if l := len("uration"); len(elem) >= l && elem[0:l] == "uration" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDurationRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDurationArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringDurationArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDurationNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringDurationNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringDurationNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + } + case 'e': // Prefix: "email" + if l := len("email"); len(elem) >= l && elem[0:l] == "email" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringEmailRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } switch elem[0] { case '_': // Prefix: "_" if l := len("_"); len(elem) >= l && elem[0:l] == "_" { @@ -13384,7 +13576,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringPasswordArrayRequest([0]string{}, w, r) + s.handleTestResponseStringEmailArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13403,7 +13595,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringPasswordArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringEmailArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13421,7 +13613,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringPasswordNullableRequest([0]string{}, w, r) + s.handleTestResponseStringEmailNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13439,7 +13631,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringPasswordNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringEmailNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13458,7 +13650,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringPasswordNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringEmailNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13469,8 +13661,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 't': // Prefix: "time" - if l := len("time"); len(elem) >= l && elem[0:l] == "time" { + case 'h': // Prefix: "hostname" + if l := len("hostname"); len(elem) >= l && elem[0:l] == "hostname" { elem = elem[l:] } else { break @@ -13479,7 +13671,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringTimeRequest([0]string{}, w, r) + s.handleTestResponseStringHostnameRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13508,7 +13700,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringTimeArrayRequest([0]string{}, w, r) + s.handleTestResponseStringHostnameArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13527,7 +13719,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringTimeArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringHostnameArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13545,7 +13737,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringTimeNullableRequest([0]string{}, w, r) + s.handleTestResponseStringHostnameNullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13563,7 +13755,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringTimeNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringHostnameNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13582,7 +13774,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringTimeNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringHostnameNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13593,8 +13785,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 'u': // Prefix: "u" - if l := len("u"); len(elem) >= l && elem[0:l] == "u" { + case 'i': // Prefix: "i" + if l := len("i"); len(elem) >= l && elem[0:l] == "i" { elem = elem[l:] } else { break @@ -13604,37 +13796,37 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'n': // Prefix: "nix" - if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { + case 'n': // Prefix: "nt" + if l := len("nt"); len(elem) >= l && elem[0:l] == "nt" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUnixRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseStringInt32Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break @@ -13644,8 +13836,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -13654,7 +13846,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixMicroRequest([0]string{}, w, r) + s.handleTestResponseStringInt32ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13662,114 +13854,151 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringInt32ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMicroArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringInt32NullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMicroArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringInt32NullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixMicroNullableRequest([0]string{}, w, r) + s.handleTestResponseStringInt32NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMicroNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringInt64Request([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMicroNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringInt64ArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringInt64ArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } + + return } } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -13778,7 +14007,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixMilliRequest([0]string{}, w, r) + s.handleTestResponseStringInt64NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13786,115 +14015,183 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseStringInt64NullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixMilliArrayRequest([0]string{}, w, r) + s.handleTestResponseStringInt64NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMilliArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + } + } + } + } + case 'p': // Prefix: "p" + if l := len("p"); len(elem) >= l && elem[0:l] == "p" { + elem = elem[l:] + } else { + break + } - return - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringIPRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMilliNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMilliNullableArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringIPArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringUnixMilliNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringIPArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - return - } - } + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringIPNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringIPNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringIPNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } + + return } } } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + } + case 'v': // Prefix: "v" + if l := len("v"); len(elem) >= l && elem[0:l] == "v" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '4': // Prefix: "4" + if l := len("4"); len(elem) >= l && elem[0:l] == "4" { elem = elem[l:] } else { break @@ -13903,7 +14200,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixNanoRequest([0]string{}, w, r) + s.handleTestResponseStringIpv4Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13932,7 +14229,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixNanoArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv4ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13951,7 +14248,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixNanoArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv4ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13969,7 +14266,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixNanoNullableRequest([0]string{}, w, r) + s.handleTestResponseStringIpv4NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -13987,7 +14284,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixNanoNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv4NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14006,7 +14303,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv4NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14017,8 +14314,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + case '6': // Prefix: "6" + if l := len("6"); len(elem) >= l && elem[0:l] == "6" { elem = elem[l:] } else { break @@ -14027,7 +14324,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixSecondsRequest([0]string{}, w, r) + s.handleTestResponseStringIpv6Request([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14056,7 +14353,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixSecondsArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv6ArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14075,7 +14372,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixSecondsArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv6ArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14093,7 +14390,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixSecondsNullableRequest([0]string{}, w, r) + s.handleTestResponseStringIpv6NullableRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14111,7 +14408,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixSecondsNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv6NullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14130,7 +14427,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringIpv6NullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14142,56 +14439,150 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } } } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + case 'p': // Prefix: "password" + if l := len("password"); len(elem) >= l && elem[0:l] == "password" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringPasswordRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringPasswordArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixArrayRequest([0]string{}, w, r) + s.handleTestResponseStringPasswordArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringUnixArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringPasswordNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -14200,7 +14591,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUnixNullableRequest([0]string{}, w, r) + s.handleTestResponseStringPasswordNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14216,106 +14607,106 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUnixNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringPasswordNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringUnixNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } - case 'r': // Prefix: "ri" - if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { + } + case 't': // Prefix: "time" + if l := len("time"); len(elem) >= l && elem[0:l] == "time" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringTimeRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringURIRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch r.Method { + case "POST": + s.handleTestResponseStringTimeArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringURIArrayRequest([0]string{}, w, r) + s.handleTestResponseStringTimeArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringURIArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringTimeNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -14324,7 +14715,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringURINullableRequest([0]string{}, w, r) + s.handleTestResponseStringTimeNullableArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14340,58 +14731,51 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } if len(elem) == 0 { + // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringURINullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringTimeNullableArrayArrayRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringURINullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return - } - } } } } - case 'u': // Prefix: "uid" - if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUUIDRequest([0]string{}, w, r) - default: + } + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixRequest([0]string{}, w, r) + default: s.notAllowed(w, r, "POST") } return } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break @@ -14401,63 +14785,143 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUUIDArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch r.Method { case "POST": - s.handleTestResponseStringUUIDArrayArrayRequest([0]string{}, w, r) + s.handleTestResponseStringUnixMicroRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } return } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { - case "POST": - s.handleTestResponseStringUUIDNullableRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - return - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMicroArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMicroArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMicroNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMicroNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMicroNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break @@ -14466,7 +14930,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { switch r.Method { case "POST": - s.handleTestResponseStringUUIDNullableArrayRequest([0]string{}, w, r) + s.handleTestResponseStringUnixMilliRequest([0]string{}, w, r) default: s.notAllowed(w, r, "POST") } @@ -14474,264 +14938,1372 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTestResponseStringUUIDNullableArrayArrayRequest([0]string{}, w, r) - default: - s.notAllowed(w, r, "POST") - } - - return + break } - } - } - } - } - } - } - } - } - } - } - } - } - s.notFound(w, r) -} + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } -// Route is route object. -type Route struct { - name string - operationID string - count int - args [0]string -} + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMilliArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } -// Name returns ogen operation name. -// -// It is guaranteed to be unique and not empty. -func (r Route) Name() string { - return r.name -} + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } -// OperationID returns OpenAPI operationId. -func (r Route) OperationID() string { - return r.operationID -} + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMilliArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } -// Args returns parsed arguments. -func (r Route) Args() []string { - return r.args[:r.count] -} + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } -// FindRoute finds Route for given method and path. -func (s *Server) FindRoute(method, path string) (r Route, _ bool) { - var ( - args = [0]string{} - elem = path - ) - r.args = args - if elem == "" { - return r, false - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMilliNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - // Static code generated router with unwrapped path search. - switch { - default: - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/test_" - if l := len("/test_"); len(elem) >= l && elem[0:l] == "/test_" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'q': // Prefix: "query_parameter" - if l := len("query_parameter"); len(elem) >= l && elem[0:l] == "query_parameter" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMilliNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestQueryParameter - r.name = "TestQueryParameter" - r.operationID = "test_query_parameter" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - case 'r': // Prefix: "re" - if l := len("re"); len(elem) >= l && elem[0:l] == "re" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'q': // Prefix: "quest_" - if l := len("quest_"); len(elem) >= l && elem[0:l] == "quest_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixMilliNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'A': // Prefix: "Any" - if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { - elem = elem[l:] - } else { - break - } + return + } + } + } + } + } + } + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestAny - r.name = "TestRequestAny" - r.operationID = "test_request_Any" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - case 'E': // Prefix: "EmptyStruct" - if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNanoRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestEmptyStruct - r.name = "TestRequestEmptyStruct" - r.operationID = "test_request_EmptyStruct" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - case 'F': // Prefix: "FormatTest" - if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestFormatTest - r.name = "TestRequestFormatTest" - r.operationID = "test_request_FormatTest" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - case 'b': // Prefix: "boolean" - if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestBoolean" - r.operationID = "test_request_boolean" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNanoArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNanoArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNanoNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNanoNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNanoNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixSecondsRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixSecondsArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixSecondsArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixSecondsNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixSecondsNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixSecondsNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + } + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUnixNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'r': // Prefix: "ri" + if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringURIRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringURIArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringURIArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringURINullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringURINullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringURINullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + case 'u': // Prefix: "uid" + if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUUIDRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUUIDArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUUIDArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUUIDNullableRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringUUIDNullableArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTestResponseStringUUIDNullableArrayArrayRequest([0]string{}, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + } + } + } + } + } + } + } + } + } + } + } + } + s.notFound(w, r) +} + +// Route is route object. +type Route struct { + name string + operationID string + count int + args [0]string +} + +// Name returns ogen operation name. +// +// It is guaranteed to be unique and not empty. +func (r Route) Name() string { + return r.name +} + +// OperationID returns OpenAPI operationId. +func (r Route) OperationID() string { + return r.operationID +} + +// Args returns parsed arguments. +func (r Route) Args() []string { + return r.args[:r.count] +} + +// FindRoute finds Route for given method and path. +func (s *Server) FindRoute(method, path string) (r Route, _ bool) { + var ( + args = [0]string{} + elem = path + ) + r.args = args + if elem == "" { + return r, false + } + + // Static code generated router with unwrapped path search. + switch { + default: + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/test_" + if l := len("/test_"); len(elem) >= l && elem[0:l] == "/test_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'q': // Prefix: "query_parameter" + if l := len("query_parameter"); len(elem) >= l && elem[0:l] == "query_parameter" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestQueryParameter + r.name = "TestQueryParameter" + r.operationID = "test_query_parameter" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + case 'r': // Prefix: "re" + if l := len("re"); len(elem) >= l && elem[0:l] == "re" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'q': // Prefix: "quest_" + if l := len("quest_"); len(elem) >= l && elem[0:l] == "quest_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'A': // Prefix: "Any" + if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestAny + r.name = "TestRequestAny" + r.operationID = "test_request_Any" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + case 'E': // Prefix: "EmptyStruct" + if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestEmptyStruct + r.name = "TestRequestEmptyStruct" + r.operationID = "test_request_EmptyStruct" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + case 'F': // Prefix: "FormatTest" + if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestFormatTest + r.name = "TestRequestFormatTest" + r.operationID = "test_request_FormatTest" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + case 'b': // Prefix: "boolean" + if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestBoolean" + r.operationID = "test_request_boolean" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestBooleanArray" + r.operationID = "test_request_boolean_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestBooleanArrayArray + r.name = "TestRequestBooleanArrayArray" + r.operationID = "test_request_boolean_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestBooleanNullable" + r.operationID = "test_request_boolean_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestBooleanNullableArray" + r.operationID = "test_request_boolean_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestBooleanNullableArrayArray + r.name = "TestRequestBooleanNullableArrayArray" + r.operationID = "test_request_boolean_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } + } + case 'i': // Prefix: "integer" + if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestInteger" + r.operationID = "test_request_integer" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerArray" + r.operationID = "test_request_integer_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerArrayArray + r.name = "TestRequestIntegerArrayArray" + r.operationID = "test_request_integer_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt32" + r.operationID = "test_request_integer_int32" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt32Array" + r.operationID = "test_request_integer_int32_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerInt32ArrayArray + r.name = "TestRequestIntegerInt32ArrayArray" + r.operationID = "test_request_integer_int32_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt32Nullable" + r.operationID = "test_request_integer_int32_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt32NullableArray" + r.operationID = "test_request_integer_int32_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerInt32NullableArrayArray + r.name = "TestRequestIntegerInt32NullableArrayArray" + r.operationID = "test_request_integer_int32_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } + } + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt64" + r.operationID = "test_request_integer_int64" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt64Array" + r.operationID = "test_request_integer_int64_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerInt64ArrayArray + r.name = "TestRequestIntegerInt64ArrayArray" + r.operationID = "test_request_integer_int64_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt64Nullable" + r.operationID = "test_request_integer_int64_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestBooleanArray" - r.operationID = "test_request_boolean_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerInt64NullableArray" + r.operationID = "test_request_integer_int64_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestBooleanArrayArray - r.name = "TestRequestBooleanArrayArray" - r.operationID = "test_request_boolean_array_array" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerInt64NullableArrayArray + r.name = "TestRequestIntegerInt64NullableArrayArray" + r.operationID = "test_request_integer_int64_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } } } } @@ -14745,8 +16317,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestBooleanNullable" - r.operationID = "test_request_boolean_nullable" + r.name = "TestRequestIntegerNullable" + r.operationID = "test_request_integer_nullable" r.args = args r.count = 0 return r, true @@ -14765,8 +16337,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestBooleanNullableArray" - r.operationID = "test_request_boolean_nullable_array" + r.name = "TestRequestIntegerNullableArray" + r.operationID = "test_request_integer_nullable_array" r.args = args r.count = 0 return r, true @@ -14785,9 +16357,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestBooleanNullableArrayArray - r.name = "TestRequestBooleanNullableArrayArray" - r.operationID = "test_request_boolean_nullable_array_array" + // Leaf: TestRequestIntegerNullableArrayArray + r.name = "TestRequestIntegerNullableArrayArray" + r.operationID = "test_request_integer_nullable_array_array" r.args = args r.count = 0 return r, true @@ -14797,61 +16369,19 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - } - } - case 'i': // Prefix: "integer" - if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestInteger" - r.operationID = "test_request_integer" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerArray" - r.operationID = "test_request_integer_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { elem = elem[l:] } else { break @@ -14860,9 +16390,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerArrayArray - r.name = "TestRequestIntegerArrayArray" - r.operationID = "test_request_integer_array_array" + r.name = "TestRequestIntegerUint" + r.operationID = "test_request_integer_uint" r.args = args r.count = 0 return r, true @@ -14870,71 +16399,176 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerUint32" + r.operationID = "test_request_integer_uint32" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerUint32Array" + r.operationID = "test_request_integer_uint32_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUint32ArrayArray + r.name = "TestRequestIntegerUint32ArrayArray" + r.operationID = "test_request_integer_uint32_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerUint32Nullable" + r.operationID = "test_request_integer_uint32_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestIntegerUint32NullableArray" + r.operationID = "test_request_integer_uint32_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerInt32" - r.operationID = "test_request_integer_int32" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUint32NullableArrayArray + r.name = "TestRequestIntegerUint32NullableArrayArray" + r.operationID = "test_request_integer_uint32_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestIntegerUint64" + r.operationID = "test_request_integer_uint64" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerInt32Array" - r.operationID = "test_request_integer_int32_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -14943,9 +16577,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerInt32ArrayArray - r.name = "TestRequestIntegerInt32ArrayArray" - r.operationID = "test_request_integer_int32_array_array" + r.name = "TestRequestIntegerUint64Array" + r.operationID = "test_request_integer_uint64_array" r.args = args r.count = 0 return r, true @@ -14953,29 +16586,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerInt32Nullable" - r.operationID = "test_request_integer_int32_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUint64ArrayArray + r.name = "TestRequestIntegerUint64ArrayArray" + r.operationID = "test_request_integer_uint64_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -14984,8 +16618,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerInt32NullableArray" - r.operationID = "test_request_integer_int32_nullable_array" + r.name = "TestRequestIntegerUint64Nullable" + r.operationID = "test_request_integer_uint64_nullable" r.args = args r.count = 0 return r, true @@ -15004,9 +16638,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerInt32NullableArrayArray - r.name = "TestRequestIntegerInt32NullableArrayArray" - r.operationID = "test_request_integer_int32_nullable_array_array" + r.name = "TestRequestIntegerUint64NullableArray" + r.operationID = "test_request_integer_uint64_nullable_array" r.args = args r.count = 0 return r, true @@ -15014,30 +16647,31 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUint64NullableArrayArray + r.name = "TestRequestIntegerUint64NullableArrayArray" + r.operationID = "test_request_integer_uint64_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } - } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerInt64" - r.operationID = "test_request_integer_int64" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { case '_': // Prefix: "_" if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] @@ -15059,8 +16693,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerInt64Array" - r.operationID = "test_request_integer_int64_array" + r.name = "TestRequestIntegerUintArray" + r.operationID = "test_request_integer_uint_array" r.args = args r.count = 0 return r, true @@ -15079,9 +16713,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerInt64ArrayArray - r.name = "TestRequestIntegerInt64ArrayArray" - r.operationID = "test_request_integer_int64_array_array" + // Leaf: TestRequestIntegerUintArrayArray + r.name = "TestRequestIntegerUintArrayArray" + r.operationID = "test_request_integer_uint_array_array" r.args = args r.count = 0 return r, true @@ -15100,8 +16734,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerInt64Nullable" - r.operationID = "test_request_integer_int64_nullable" + r.name = "TestRequestIntegerUintNullable" + r.operationID = "test_request_integer_uint_nullable" r.args = args r.count = 0 return r, true @@ -15120,8 +16754,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerInt64NullableArray" - r.operationID = "test_request_integer_int64_nullable_array" + r.name = "TestRequestIntegerUintNullableArray" + r.operationID = "test_request_integer_uint_nullable_array" r.args = args r.count = 0 return r, true @@ -15140,116 +16774,42 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerInt64NullableArrayArray - r.name = "TestRequestIntegerInt64NullableArrayArray" - r.operationID = "test_request_integer_int64_nullable_array_array" + // Leaf: TestRequestIntegerUintNullableArrayArray + r.name = "TestRequestIntegerUintNullableArrayArray" + r.operationID = "test_request_integer_uint_nullable_array_array" r.args = args r.count = 0 return r, true - default: - return - } - } - } - } - } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerNullable" - r.operationID = "test_request_integer_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerNullableArray" - r.operationID = "test_request_integer_nullable_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestIntegerNullableArrayArray - r.name = "TestRequestIntegerNullableArrayArray" - r.operationID = "test_request_integer_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - } - case 'u': // Prefix: "unix" - if l := len("unix"); len(elem) >= l && elem[0:l] == "unix" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnix" - r.operationID = "test_request_integer_unix" - r.args = args - r.count = 0 - return r, true - default: - return + default: + return + } + } + } + } + } } - } - switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestIntegerUnix" + r.operationID = "test_request_integer_unix" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break @@ -15259,59 +16819,50 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { break } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixMicro" - r.operationID = "test_request_integer_unix-micro" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestIntegerUnixMicro" + r.operationID = "test_request_integer_unix-micro" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixMicroArray" - r.operationID = "test_request_integer_unix-micro_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -15320,9 +16871,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixMicroArrayArray - r.name = "TestRequestIntegerUnixMicroArrayArray" - r.operationID = "test_request_integer_unix-micro_array_array" + r.name = "TestRequestIntegerUnixMicroArray" + r.operationID = "test_request_integer_unix-micro_array" r.args = args r.count = 0 return r, true @@ -15330,29 +16880,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixMicroNullable" - r.operationID = "test_request_integer_unix-micro_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixMicroArrayArray + r.name = "TestRequestIntegerUnixMicroArrayArray" + r.operationID = "test_request_integer_unix-micro_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -15361,8 +16912,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerUnixMicroNullableArray" - r.operationID = "test_request_integer_unix-micro_nullable_array" + r.name = "TestRequestIntegerUnixMicroNullable" + r.operationID = "test_request_integer_unix-micro_nullable" r.args = args r.count = 0 return r, true @@ -15381,9 +16932,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixMicroNullableArrayArray - r.name = "TestRequestIntegerUnixMicroNullableArrayArray" - r.operationID = "test_request_integer_unix-micro_nullable_array_array" + r.name = "TestRequestIntegerUnixMicroNullableArray" + r.operationID = "test_request_integer_unix-micro_nullable_array" r.args = args r.count = 0 return r, true @@ -15391,63 +16941,64 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixMicroNullableArrayArray + r.name = "TestRequestIntegerUnixMicroNullableArrayArray" + r.operationID = "test_request_integer_unix-micro_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } - } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixMilli" - r.operationID = "test_request_integer_unix-milli" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestIntegerUnixMilli" + r.operationID = "test_request_integer_unix-milli" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixMilliArray" - r.operationID = "test_request_integer_unix-milli_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -15456,9 +17007,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixMilliArrayArray - r.name = "TestRequestIntegerUnixMilliArrayArray" - r.operationID = "test_request_integer_unix-milli_array_array" + r.name = "TestRequestIntegerUnixMilliArray" + r.operationID = "test_request_integer_unix-milli_array" r.args = args r.count = 0 return r, true @@ -15466,29 +17016,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixMilliNullable" - r.operationID = "test_request_integer_unix-milli_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixMilliArrayArray + r.name = "TestRequestIntegerUnixMilliArrayArray" + r.operationID = "test_request_integer_unix-milli_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -15497,8 +17048,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerUnixMilliNullableArray" - r.operationID = "test_request_integer_unix-milli_nullable_array" + r.name = "TestRequestIntegerUnixMilliNullable" + r.operationID = "test_request_integer_unix-milli_nullable" r.args = args r.count = 0 return r, true @@ -15517,9 +17068,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixMilliNullableArrayArray - r.name = "TestRequestIntegerUnixMilliNullableArrayArray" - r.operationID = "test_request_integer_unix-milli_nullable_array_array" + r.name = "TestRequestIntegerUnixMilliNullableArray" + r.operationID = "test_request_integer_unix-milli_nullable_array" r.args = args r.count = 0 return r, true @@ -15527,64 +17077,65 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixMilliNullableArrayArray + r.name = "TestRequestIntegerUnixMilliNullableArrayArray" + r.operationID = "test_request_integer_unix-milli_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } } - } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixNano" - r.operationID = "test_request_integer_unix-nano" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestIntegerUnixNano" + r.operationID = "test_request_integer_unix-nano" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixNanoArray" - r.operationID = "test_request_integer_unix-nano_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -15593,9 +17144,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixNanoArrayArray - r.name = "TestRequestIntegerUnixNanoArrayArray" - r.operationID = "test_request_integer_unix-nano_array_array" + r.name = "TestRequestIntegerUnixNanoArray" + r.operationID = "test_request_integer_unix-nano_array" r.args = args r.count = 0 return r, true @@ -15603,29 +17153,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixNanoNullable" - r.operationID = "test_request_integer_unix-nano_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixNanoArrayArray + r.name = "TestRequestIntegerUnixNanoArrayArray" + r.operationID = "test_request_integer_unix-nano_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -15634,8 +17185,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerUnixNanoNullableArray" - r.operationID = "test_request_integer_unix-nano_nullable_array" + r.name = "TestRequestIntegerUnixNanoNullable" + r.operationID = "test_request_integer_unix-nano_nullable" r.args = args r.count = 0 return r, true @@ -15654,9 +17205,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixNanoNullableArrayArray - r.name = "TestRequestIntegerUnixNanoNullableArrayArray" - r.operationID = "test_request_integer_unix-nano_nullable_array_array" + r.name = "TestRequestIntegerUnixNanoNullableArray" + r.operationID = "test_request_integer_unix-nano_nullable_array" r.args = args r.count = 0 return r, true @@ -15664,63 +17214,64 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixNanoNullableArrayArray + r.name = "TestRequestIntegerUnixNanoNullableArrayArray" + r.operationID = "test_request_integer_unix-nano_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } - } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixSeconds" - r.operationID = "test_request_integer_unix-seconds" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestIntegerUnixSeconds" + r.operationID = "test_request_integer_unix-seconds" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixSecondsArray" - r.operationID = "test_request_integer_unix-seconds_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -15729,9 +17280,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixSecondsArrayArray - r.name = "TestRequestIntegerUnixSecondsArrayArray" - r.operationID = "test_request_integer_unix-seconds_array_array" + r.name = "TestRequestIntegerUnixSecondsArray" + r.operationID = "test_request_integer_unix-seconds_array" r.args = args r.count = 0 return r, true @@ -15739,29 +17289,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixSecondsNullable" - r.operationID = "test_request_integer_unix-seconds_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixSecondsArrayArray + r.name = "TestRequestIntegerUnixSecondsArrayArray" + r.operationID = "test_request_integer_unix-seconds_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -15770,8 +17321,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerUnixSecondsNullableArray" - r.operationID = "test_request_integer_unix-seconds_nullable_array" + r.name = "TestRequestIntegerUnixSecondsNullable" + r.operationID = "test_request_integer_unix-seconds_nullable" r.args = args r.count = 0 return r, true @@ -15790,9 +17341,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixSecondsNullableArrayArray - r.name = "TestRequestIntegerUnixSecondsNullableArrayArray" - r.operationID = "test_request_integer_unix-seconds_nullable_array_array" + r.name = "TestRequestIntegerUnixSecondsNullableArray" + r.operationID = "test_request_integer_unix-seconds_nullable_array" r.args = args r.count = 0 return r, true @@ -15800,44 +17350,45 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixSecondsNullableArrayArray + r.name = "TestRequestIntegerUnixSecondsNullableArrayArray" + r.operationID = "test_request_integer_unix-seconds_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } } - } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixArray" - r.operationID = "test_request_integer_unix_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -15846,9 +17397,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixArrayArray - r.name = "TestRequestIntegerUnixArrayArray" - r.operationID = "test_request_integer_unix_array_array" + r.name = "TestRequestIntegerUnixArray" + r.operationID = "test_request_integer_unix_array" r.args = args r.count = 0 return r, true @@ -15856,29 +17406,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestIntegerUnixNullable" - r.operationID = "test_request_integer_unix_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixArrayArray + r.name = "TestRequestIntegerUnixArrayArray" + r.operationID = "test_request_integer_unix_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -15887,8 +17438,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestIntegerUnixNullableArray" - r.operationID = "test_request_integer_unix_nullable_array" + r.name = "TestRequestIntegerUnixNullable" + r.operationID = "test_request_integer_unix_nullable" r.args = args r.count = 0 return r, true @@ -15907,9 +17458,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestIntegerUnixNullableArrayArray - r.name = "TestRequestIntegerUnixNullableArrayArray" - r.operationID = "test_request_integer_unix_nullable_array_array" + r.name = "TestRequestIntegerUnixNullableArray" + r.operationID = "test_request_integer_unix_nullable_array" r.args = args r.count = 0 return r, true @@ -15917,6 +17467,28 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestIntegerUnixNullableArrayArray + r.name = "TestRequestIntegerUnixNullableArrayArray" + r.operationID = "test_request_integer_unix_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } @@ -16892,42 +18464,305 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { break } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestRequiredBooleanArrayArray - r.name = "TestRequestRequiredBooleanArrayArray" - r.operationID = "test_request_required_boolean_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredBooleanArrayArray + r.name = "TestRequestRequiredBooleanArrayArray" + r.operationID = "test_request_required_boolean_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredBooleanNullable" + r.operationID = "test_request_required_boolean_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredBooleanNullableArray" + r.operationID = "test_request_required_boolean_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredBooleanNullableArrayArray + r.name = "TestRequestRequiredBooleanNullableArrayArray" + r.operationID = "test_request_required_boolean_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } + } + case 'i': // Prefix: "integer" + if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredInteger" + r.operationID = "test_request_required_integer" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerArray" + r.operationID = "test_request_required_integer_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerArrayArray + r.name = "TestRequestRequiredIntegerArrayArray" + r.operationID = "test_request_required_integer_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerInt32" + r.operationID = "test_request_required_integer_int32" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerInt32Array" + r.operationID = "test_request_required_integer_int32_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerInt32ArrayArray + r.name = "TestRequestRequiredIntegerInt32ArrayArray" + r.operationID = "test_request_required_integer_int32_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerInt32Nullable" + r.operationID = "test_request_required_integer_int32_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerInt32NullableArray" + r.operationID = "test_request_required_integer_int32_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredBooleanNullable" - r.operationID = "test_request_required_boolean_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerInt32NullableArrayArray + r.name = "TestRequestRequiredIntegerInt32NullableArrayArray" + r.operationID = "test_request_required_integer_int32_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break @@ -16936,8 +18771,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredBooleanNullableArray" - r.operationID = "test_request_required_boolean_nullable_array" + r.name = "TestRequestRequiredIntegerInt64" + r.operationID = "test_request_required_integer_int64" r.args = args r.count = 0 return r, true @@ -16946,63 +18781,125 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestRequiredBooleanNullableArrayArray - r.name = "TestRequestRequiredBooleanNullableArrayArray" - r.operationID = "test_request_required_boolean_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerInt64Array" + r.operationID = "test_request_required_integer_int64_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerInt64ArrayArray + r.name = "TestRequestRequiredIntegerInt64ArrayArray" + r.operationID = "test_request_required_integer_int64_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerInt64Nullable" + r.operationID = "test_request_required_integer_int64_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerInt64NullableArray" + r.operationID = "test_request_required_integer_int64_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerInt64NullableArrayArray + r.name = "TestRequestRequiredIntegerInt64NullableArrayArray" + r.operationID = "test_request_required_integer_int64_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } } - } - } - case 'i': // Prefix: "integer" - if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredInteger" - r.operationID = "test_request_required_integer" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -17011,8 +18908,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerArray" - r.operationID = "test_request_required_integer_array" + r.name = "TestRequestRequiredIntegerNullable" + r.operationID = "test_request_required_integer_nullable" r.args = args r.count = 0 return r, true @@ -17031,9 +18928,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerArrayArray - r.name = "TestRequestRequiredIntegerArrayArray" - r.operationID = "test_request_required_integer_array_array" + r.name = "TestRequestRequiredIntegerNullableArray" + r.operationID = "test_request_required_integer_nullable_array" r.args = args r.count = 0 return r, true @@ -17041,9 +18937,31 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerNullableArrayArray + r.name = "TestRequestRequiredIntegerNullableArrayArray" + r.operationID = "test_request_required_integer_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { elem = elem[l:] } else { break @@ -17053,8 +18971,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { break } switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { elem = elem[l:] } else { break @@ -17063,8 +18981,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerInt32" - r.operationID = "test_request_required_integer_int32" + r.name = "TestRequestRequiredIntegerUint" + r.operationID = "test_request_required_integer_uint" r.args = args r.count = 0 return r, true @@ -17073,39 +18991,39 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUint32" + r.operationID = "test_request_required_integer_uint32" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerInt32Array" - r.operationID = "test_request_required_integer_int32_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -17114,9 +19032,49 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerInt32ArrayArray - r.name = "TestRequestRequiredIntegerInt32ArrayArray" - r.operationID = "test_request_required_integer_int32_array_array" + r.name = "TestRequestRequiredIntegerUint32Array" + r.operationID = "test_request_required_integer_uint32_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUint32ArrayArray + r.name = "TestRequestRequiredIntegerUint32ArrayArray" + r.operationID = "test_request_required_integer_uint32_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUint32Nullable" + r.operationID = "test_request_required_integer_uint32_nullable" r.args = args r.count = 0 return r, true @@ -17124,29 +19082,84 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUint32NullableArray" + r.operationID = "test_request_required_integer_uint32_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUint32NullableArrayArray + r.name = "TestRequestRequiredIntegerUint32NullableArrayArray" + r.operationID = "test_request_required_integer_uint32_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + } + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUint64" + r.operationID = "test_request_required_integer_uint64" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerInt32Nullable" - r.operationID = "test_request_required_integer_int32_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -17155,8 +19168,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerInt32NullableArray" - r.operationID = "test_request_required_integer_int32_nullable_array" + r.name = "TestRequestRequiredIntegerUint64Array" + r.operationID = "test_request_required_integer_uint64_array" r.args = args r.count = 0 return r, true @@ -17175,9 +19188,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerInt32NullableArrayArray - r.name = "TestRequestRequiredIntegerInt32NullableArrayArray" - r.operationID = "test_request_required_integer_int32_nullable_array_array" + // Leaf: TestRequestRequiredIntegerUint64ArrayArray + r.name = "TestRequestRequiredIntegerUint64ArrayArray" + r.operationID = "test_request_required_integer_uint64_array_array" r.args = args r.count = 0 return r, true @@ -17186,29 +19199,70 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - } - } - } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { - elem = elem[l:] - } else { - break - } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerInt64" - r.operationID = "test_request_required_integer_int64" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUint64Nullable" + r.operationID = "test_request_required_integer_uint64_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUint64NullableArray" + r.operationID = "test_request_required_integer_uint64_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUint64NullableArrayArray + r.name = "TestRequestRequiredIntegerUint64NullableArrayArray" + r.operationID = "test_request_required_integer_uint64_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } } - } - switch elem[0] { case '_': // Prefix: "_" if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] @@ -17230,8 +19284,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerInt64Array" - r.operationID = "test_request_required_integer_int64_array" + r.name = "TestRequestRequiredIntegerUintArray" + r.operationID = "test_request_required_integer_uint_array" r.args = args r.count = 0 return r, true @@ -17250,9 +19304,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerInt64ArrayArray - r.name = "TestRequestRequiredIntegerInt64ArrayArray" - r.operationID = "test_request_required_integer_int64_array_array" + // Leaf: TestRequestRequiredIntegerUintArrayArray + r.name = "TestRequestRequiredIntegerUintArrayArray" + r.operationID = "test_request_required_integer_uint_array_array" r.args = args r.count = 0 return r, true @@ -17271,8 +19325,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerInt64Nullable" - r.operationID = "test_request_required_integer_int64_nullable" + r.name = "TestRequestRequiredIntegerUintNullable" + r.operationID = "test_request_required_integer_uint_nullable" r.args = args r.count = 0 return r, true @@ -17291,8 +19345,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerInt64NullableArray" - r.operationID = "test_request_required_integer_int64_nullable_array" + r.name = "TestRequestRequiredIntegerUintNullableArray" + r.operationID = "test_request_required_integer_uint_nullable_array" r.args = args r.count = 0 return r, true @@ -17311,9 +19365,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerInt64NullableArrayArray - r.name = "TestRequestRequiredIntegerInt64NullableArrayArray" - r.operationID = "test_request_required_integer_int64_nullable_array_array" + // Leaf: TestRequestRequiredIntegerUintNullableArrayArray + r.name = "TestRequestRequiredIntegerUintNullableArrayArray" + r.operationID = "test_request_required_integer_uint_nullable_array_array" r.args = args r.count = 0 return r, true @@ -17325,29 +19379,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerNullable" - r.operationID = "test_request_required_integer_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { elem = elem[l:] } else { break @@ -17356,8 +19389,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerNullableArray" - r.operationID = "test_request_required_integer_nullable_array" + r.name = "TestRequestRequiredIntegerUnix" + r.operationID = "test_request_required_integer_unix" r.args = args r.count = 0 return r, true @@ -17366,61 +19399,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestRequiredIntegerNullableArrayArray - r.name = "TestRequestRequiredIntegerNullableArrayArray" - r.operationID = "test_request_required_integer_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - } - case 'u': // Prefix: "unix" - if l := len("unix"); len(elem) >= l && elem[0:l] == "unix" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnix" - r.operationID = "test_request_required_integer_unix" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break @@ -17430,59 +19410,91 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { break } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixMicro" - r.operationID = "test_request_required_integer_unix-micro" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUnixMicro" + r.operationID = "test_request_required_integer_unix-micro" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixMicroArray" - r.operationID = "test_request_required_integer_unix-micro_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUnixMicroArray" + r.operationID = "test_request_required_integer_unix-micro_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUnixMicroArrayArray + r.name = "TestRequestRequiredIntegerUnixMicroArrayArray" + r.operationID = "test_request_required_integer_unix-micro_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -17491,9 +19503,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixMicroArrayArray - r.name = "TestRequestRequiredIntegerUnixMicroArrayArray" - r.operationID = "test_request_required_integer_unix-micro_array_array" + r.name = "TestRequestRequiredIntegerUnixMicroNullable" + r.operationID = "test_request_required_integer_unix-micro_nullable" r.args = args r.count = 0 return r, true @@ -17501,29 +19512,125 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUnixMicroNullableArray" + r.operationID = "test_request_required_integer_unix-micro_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUnixMicroNullableArrayArray + r.name = "TestRequestRequiredIntegerUnixMicroNullableArrayArray" + r.operationID = "test_request_required_integer_unix-micro_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + } + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUnixMilli" + r.operationID = "test_request_required_integer_unix-milli" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixMicroNullable" - r.operationID = "test_request_required_integer_unix-micro_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUnixMilliArray" + r.operationID = "test_request_required_integer_unix-milli_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUnixMilliArrayArray + r.name = "TestRequestRequiredIntegerUnixMilliArrayArray" + r.operationID = "test_request_required_integer_unix-milli_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -17532,8 +19639,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixMicroNullableArray" - r.operationID = "test_request_required_integer_unix-micro_nullable_array" + r.name = "TestRequestRequiredIntegerUnixMilliNullable" + r.operationID = "test_request_required_integer_unix-milli_nullable" r.args = args r.count = 0 return r, true @@ -17552,9 +19659,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixMicroNullableArrayArray - r.name = "TestRequestRequiredIntegerUnixMicroNullableArrayArray" - r.operationID = "test_request_required_integer_unix-micro_nullable_array_array" + r.name = "TestRequestRequiredIntegerUnixMilliNullableArray" + r.operationID = "test_request_required_integer_unix-milli_nullable_array" r.args = args r.count = 0 return r, true @@ -17562,12 +19668,34 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUnixMilliNullableArrayArray + r.name = "TestRequestRequiredIntegerUnixMilliNullableArrayArray" + r.operationID = "test_request_required_integer_unix-milli_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break @@ -17576,8 +19704,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixMilli" - r.operationID = "test_request_required_integer_unix-milli" + r.name = "TestRequestRequiredIntegerUnixNano" + r.operationID = "test_request_required_integer_unix-nano" r.args = args r.count = 0 return r, true @@ -17607,8 +19735,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixMilliArray" - r.operationID = "test_request_required_integer_unix-milli_array" + r.name = "TestRequestRequiredIntegerUnixNanoArray" + r.operationID = "test_request_required_integer_unix-nano_array" r.args = args r.count = 0 return r, true @@ -17627,9 +19755,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixMilliArrayArray - r.name = "TestRequestRequiredIntegerUnixMilliArrayArray" - r.operationID = "test_request_required_integer_unix-milli_array_array" + // Leaf: TestRequestRequiredIntegerUnixNanoArrayArray + r.name = "TestRequestRequiredIntegerUnixNanoArrayArray" + r.operationID = "test_request_required_integer_unix-nano_array_array" r.args = args r.count = 0 return r, true @@ -17648,8 +19776,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixMilliNullable" - r.operationID = "test_request_required_integer_unix-milli_nullable" + r.name = "TestRequestRequiredIntegerUnixNanoNullable" + r.operationID = "test_request_required_integer_unix-nano_nullable" r.args = args r.count = 0 return r, true @@ -17668,8 +19796,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixMilliNullableArray" - r.operationID = "test_request_required_integer_unix-milli_nullable_array" + r.name = "TestRequestRequiredIntegerUnixNanoNullableArray" + r.operationID = "test_request_required_integer_unix-nano_nullable_array" r.args = args r.count = 0 return r, true @@ -17688,9 +19816,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixMilliNullableArrayArray - r.name = "TestRequestRequiredIntegerUnixMilliNullableArrayArray" - r.operationID = "test_request_required_integer_unix-milli_nullable_array_array" + // Leaf: TestRequestRequiredIntegerUnixNanoNullableArrayArray + r.name = "TestRequestRequiredIntegerUnixNanoNullableArrayArray" + r.operationID = "test_request_required_integer_unix-nano_nullable_array_array" r.args = args r.count = 0 return r, true @@ -17702,101 +19830,39 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixNano" - r.operationID = "test_request_required_integer_unix-nano" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestRequiredIntegerUnixSeconds" + r.operationID = "test_request_required_integer_unix-seconds" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixNanoArray" - r.operationID = "test_request_required_integer_unix-nano_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestRequiredIntegerUnixNanoArrayArray - r.name = "TestRequestRequiredIntegerUnixNanoArrayArray" - r.operationID = "test_request_required_integer_unix-nano_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixNanoNullable" - r.operationID = "test_request_required_integer_unix-nano_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -17805,8 +19871,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixNanoNullableArray" - r.operationID = "test_request_required_integer_unix-nano_nullable_array" + r.name = "TestRequestRequiredIntegerUnixSecondsArray" + r.operationID = "test_request_required_integer_unix-seconds_array" r.args = args r.count = 0 return r, true @@ -17825,9 +19891,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixNanoNullableArrayArray - r.name = "TestRequestRequiredIntegerUnixNanoNullableArrayArray" - r.operationID = "test_request_required_integer_unix-nano_nullable_array_array" + // Leaf: TestRequestRequiredIntegerUnixSecondsArrayArray + r.name = "TestRequestRequiredIntegerUnixSecondsArrayArray" + r.operationID = "test_request_required_integer_unix-seconds_array_array" r.args = args r.count = 0 return r, true @@ -17836,103 +19902,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - } - } - } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixSeconds" - r.operationID = "test_request_required_integer_unix-seconds" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixSecondsArray" - r.operationID = "test_request_required_integer_unix-seconds_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestRequiredIntegerUnixSecondsArrayArray - r.name = "TestRequestRequiredIntegerUnixSecondsArrayArray" - r.operationID = "test_request_required_integer_unix-seconds_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixSecondsNullable" - r.operationID = "test_request_required_integer_unix-seconds_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -17941,8 +19912,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixSecondsNullableArray" - r.operationID = "test_request_required_integer_unix-seconds_nullable_array" + r.name = "TestRequestRequiredIntegerUnixSecondsNullable" + r.operationID = "test_request_required_integer_unix-seconds_nullable" r.args = args r.count = 0 return r, true @@ -17961,9 +19932,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixSecondsNullableArrayArray - r.name = "TestRequestRequiredIntegerUnixSecondsNullableArrayArray" - r.operationID = "test_request_required_integer_unix-seconds_nullable_array_array" + r.name = "TestRequestRequiredIntegerUnixSecondsNullableArray" + r.operationID = "test_request_required_integer_unix-seconds_nullable_array" r.args = args r.count = 0 return r, true @@ -17971,44 +19941,45 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUnixSecondsNullableArrayArray + r.name = "TestRequestRequiredIntegerUnixSecondsNullableArrayArray" + r.operationID = "test_request_required_integer_unix-seconds_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } } - } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixArray" - r.operationID = "test_request_required_integer_unix_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -18017,9 +19988,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixArrayArray - r.name = "TestRequestRequiredIntegerUnixArrayArray" - r.operationID = "test_request_required_integer_unix_array_array" + r.name = "TestRequestRequiredIntegerUnixArray" + r.operationID = "test_request_required_integer_unix_array" r.args = args r.count = 0 return r, true @@ -18027,29 +19997,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestRequiredIntegerUnixNullable" - r.operationID = "test_request_required_integer_unix_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUnixArrayArray + r.name = "TestRequestRequiredIntegerUnixArrayArray" + r.operationID = "test_request_required_integer_unix_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -18058,8 +20029,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestRequiredIntegerUnixNullableArray" - r.operationID = "test_request_required_integer_unix_nullable_array" + r.name = "TestRequestRequiredIntegerUnixNullable" + r.operationID = "test_request_required_integer_unix_nullable" r.args = args r.count = 0 return r, true @@ -18078,9 +20049,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestRequiredIntegerUnixNullableArrayArray - r.name = "TestRequestRequiredIntegerUnixNullableArrayArray" - r.operationID = "test_request_required_integer_unix_nullable_array_array" + r.name = "TestRequestRequiredIntegerUnixNullableArray" + r.operationID = "test_request_required_integer_unix_nullable_array" r.args = args r.count = 0 return r, true @@ -18088,6 +20058,28 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestRequiredIntegerUnixNullableArrayArray + r.name = "TestRequestRequiredIntegerUnixNullableArrayArray" + r.operationID = "test_request_required_integer_unix_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } @@ -24084,21 +26076,234 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { break } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringTimeNullableArray" - r.operationID = "test_request_string_time_nullable_array" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringTimeNullableArray" + r.operationID = "test_request_string_time_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringTimeNullableArrayArray + r.name = "TestRequestStringTimeNullableArrayArray" + r.operationID = "test_request_string_time_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } + } + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnix" + r.operationID = "test_request_string_unix" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixMicro" + r.operationID = "test_request_string_unix-micro" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixMicroArray" + r.operationID = "test_request_string_unix-micro_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringUnixMicroArrayArray + r.name = "TestRequestStringUnixMicroArrayArray" + r.operationID = "test_request_string_unix-micro_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixMicroNullable" + r.operationID = "test_request_string_unix-micro_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixMicroNullableArray" + r.operationID = "test_request_string_unix-micro_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringUnixMicroNullableArrayArray + r.name = "TestRequestStringUnixMicroNullableArrayArray" + r.operationID = "test_request_string_unix-micro_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break @@ -24107,9 +26312,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestStringTimeNullableArrayArray - r.name = "TestRequestStringTimeNullableArrayArray" - r.operationID = "test_request_string_time_nullable_array_array" + r.name = "TestRequestStringUnixMilli" + r.operationID = "test_request_string_unix-milli" r.args = args r.count = 0 return r, true @@ -24117,96 +26321,177 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - } - } - } - case 'u': // Prefix: "u" - if l := len("u"); len(elem) >= l && elem[0:l] == "u" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'n': // Prefix: "nix" - if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnix" - r.operationID = "test_request_string_unix" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixMilliArray" + r.operationID = "test_request_string_unix-milli_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringUnixMilliArrayArray + r.name = "TestRequestStringUnixMilliArrayArray" + r.operationID = "test_request_string_unix-milli_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixMilliNullable" + r.operationID = "test_request_string_unix-milli_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixMilliNullableArray" + r.operationID = "test_request_string_unix-milli_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringUnixMilliNullableArrayArray + r.name = "TestRequestStringUnixMilliNullableArrayArray" + r.operationID = "test_request_string_unix-milli_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } + } + } + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestStringUnixNano" + r.operationID = "test_request_string_unix-nano" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixMicro" - r.operationID = "test_request_string_unix-micro" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestStringUnixNanoArray" + r.operationID = "test_request_string_unix-nano_array" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -24215,8 +26500,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixMicroArray" - r.operationID = "test_request_string_unix-micro_array" + // Leaf: TestRequestStringUnixNanoArrayArray + r.name = "TestRequestStringUnixNanoArrayArray" + r.operationID = "test_request_string_unix-nano_array_array" r.args = args r.count = 0 return r, true @@ -24224,30 +26510,29 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixMicroArrayArray - r.name = "TestRequestStringUnixMicroArrayArray" - r.operationID = "test_request_string_unix-micro_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixNanoNullable" + r.operationID = "test_request_string_unix-nano_nullable" + r.args = args + r.count = 0 + return r, true + default: + return } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -24256,8 +26541,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixMicroNullable" - r.operationID = "test_request_string_unix-micro_nullable" + r.name = "TestRequestStringUnixNanoNullableArray" + r.operationID = "test_request_string_unix-nano_nullable_array" r.args = args r.count = 0 return r, true @@ -24276,8 +26561,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixMicroNullableArray" - r.operationID = "test_request_string_unix-micro_nullable_array" + // Leaf: TestRequestStringUnixNanoNullableArrayArray + r.name = "TestRequestStringUnixNanoNullableArrayArray" + r.operationID = "test_request_string_unix-nano_nullable_array_array" r.args = args r.count = 0 return r, true @@ -24285,64 +26571,63 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixMicroNullableArrayArray - r.name = "TestRequestStringUnixMicroNullableArrayArray" - r.operationID = "test_request_string_unix-micro_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } } } } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { + } + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixSeconds" + r.operationID = "test_request_string_unix-seconds" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixMilli" - r.operationID = "test_request_string_unix-milli" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestStringUnixSecondsArray" + r.operationID = "test_request_string_unix-seconds_array" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -24351,8 +26636,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixMilliArray" - r.operationID = "test_request_string_unix-milli_array" + // Leaf: TestRequestStringUnixSecondsArrayArray + r.name = "TestRequestStringUnixSecondsArrayArray" + r.operationID = "test_request_string_unix-seconds_array_array" r.args = args r.count = 0 return r, true @@ -24360,30 +26646,29 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixMilliArrayArray - r.name = "TestRequestStringUnixMilliArrayArray" - r.operationID = "test_request_string_unix-milli_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixSecondsNullable" + r.operationID = "test_request_string_unix-seconds_nullable" + r.args = args + r.count = 0 + return r, true + default: + return } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -24392,8 +26677,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixMilliNullable" - r.operationID = "test_request_string_unix-milli_nullable" + r.name = "TestRequestStringUnixSecondsNullableArray" + r.operationID = "test_request_string_unix-seconds_nullable_array" r.args = args r.count = 0 return r, true @@ -24412,8 +26697,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixMilliNullableArray" - r.operationID = "test_request_string_unix-milli_nullable_array" + // Leaf: TestRequestStringUnixSecondsNullableArrayArray + r.name = "TestRequestStringUnixSecondsNullableArrayArray" + r.operationID = "test_request_string_unix-seconds_nullable_array_array" r.args = args r.count = 0 return r, true @@ -24421,34 +26707,65 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixMilliNullableArrayArray - r.name = "TestRequestStringUnixMilliNullableArrayArray" - r.operationID = "test_request_string_unix-milli_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } } } } } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { + } + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUnixArray" + r.operationID = "test_request_string_unix_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringUnixArrayArray + r.name = "TestRequestStringUnixArrayArray" + r.operationID = "test_request_string_unix_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -24457,8 +26774,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixNano" - r.operationID = "test_request_string_unix-nano" + r.name = "TestRequestStringUnixNullable" + r.operationID = "test_request_string_unix_nullable" r.args = args r.count = 0 return r, true @@ -24467,19 +26784,28 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestStringUnixNullableArray" + r.operationID = "test_request_string_unix_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -24488,8 +26814,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixNanoArray" - r.operationID = "test_request_string_unix-nano_array" + // Leaf: TestRequestStringUnixNullableArrayArray + r.name = "TestRequestStringUnixNullableArrayArray" + r.operationID = "test_request_string_unix_nullable_array_array" r.args = args r.count = 0 return r, true @@ -24497,30 +26824,124 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + case 'r': // Prefix: "ri" + if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixNanoArrayArray - r.name = "TestRequestStringUnixNanoArrayArray" - r.operationID = "test_request_string_unix-nano_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringURI" + r.operationID = "test_request_string_uri" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringURIArray" + r.operationID = "test_request_string_uri_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringURIArrayArray + r.name = "TestRequestStringURIArrayArray" + r.operationID = "test_request_string_uri_array_array" + r.args = args + r.count = 0 + return r, true + default: + return } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringURINullable" + r.operationID = "test_request_string_uri_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringURINullableArray" + r.operationID = "test_request_string_uri_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -24529,8 +26950,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixNanoNullable" - r.operationID = "test_request_string_unix-nano_nullable" + // Leaf: TestRequestStringURINullableArrayArray + r.name = "TestRequestStringURINullableArrayArray" + r.operationID = "test_request_string_uri_nullable_array_array" r.args = args r.count = 0 return r, true @@ -24538,53 +26960,84 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + case 'u': // Prefix: "uid" + if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixNanoNullableArray" - r.operationID = "test_request_string_unix-nano_nullable_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUUID" + r.operationID = "test_request_string_uuid" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixNanoNullableArrayArray - r.name = "TestRequestStringUnixNanoNullableArrayArray" - r.operationID = "test_request_string_unix-nano_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringUUIDArray" + r.operationID = "test_request_string_uuid_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestRequestStringUUIDArrayArray + r.name = "TestRequestStringUUIDArrayArray" + r.operationID = "test_request_string_uuid_array_array" + r.args = args + r.count = 0 + return r, true + default: + return } } } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -24593,8 +27046,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixSeconds" - r.operationID = "test_request_string_unix-seconds" + r.name = "TestRequestStringUUIDNullable" + r.operationID = "test_request_string_uuid_nullable" r.args = args r.count = 0 return r, true @@ -24603,19 +27056,28 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestRequestStringUUIDNullableArray" + r.operationID = "test_request_string_uuid_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break @@ -24624,8 +27086,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUnixSecondsArray" - r.operationID = "test_request_string_unix-seconds_array" + // Leaf: TestRequestStringUUIDNullableArrayArray + r.name = "TestRequestStringUUIDNullableArrayArray" + r.operationID = "test_request_string_uuid_nullable_array_array" r.args = args r.count = 0 return r, true @@ -24633,211 +27096,306 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + } + } + } + } + case 's': // Prefix: "sponse_" + if l := len("sponse_"); len(elem) >= l && elem[0:l] == "sponse_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixSecondsArrayArray - r.name = "TestRequestStringUnixSecondsArrayArray" - r.operationID = "test_request_string_unix-seconds_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'A': // Prefix: "Any" + if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixSecondsNullable" - r.operationID = "test_request_string_unix-seconds_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseAny + r.name = "TestResponseAny" + r.operationID = "test_response_Any" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + case 'E': // Prefix: "EmptyStruct" + if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseEmptyStruct + r.name = "TestResponseEmptyStruct" + r.operationID = "test_response_EmptyStruct" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + case 'F': // Prefix: "FormatTest" + if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseFormatTest + r.name = "TestResponseFormatTest" + r.operationID = "test_response_FormatTest" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + case 'b': // Prefix: "boolean" + if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseBoolean" + r.operationID = "test_response_boolean" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseBooleanArray" + r.operationID = "test_response_boolean_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixSecondsNullableArray" - r.operationID = "test_request_string_unix-seconds_nullable_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseBooleanArrayArray + r.name = "TestResponseBooleanArrayArray" + r.operationID = "test_response_boolean_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixSecondsNullableArrayArray - r.name = "TestRequestStringUnixSecondsNullableArrayArray" - r.operationID = "test_request_string_unix-seconds_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - } - } - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseBooleanNullable" + r.operationID = "test_response_boolean_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseBooleanNullableArray" + r.operationID = "test_response_boolean_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixArray" - r.operationID = "test_request_string_unix_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + switch method { + case "POST": + // Leaf: TestResponseBooleanNullableArrayArray + r.name = "TestResponseBooleanNullableArrayArray" + r.operationID = "test_response_boolean_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + } + } + } + } + } + case 'i': // Prefix: "integer" + if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixArrayArray - r.name = "TestRequestStringUnixArrayArray" - r.operationID = "test_request_string_unix_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseInteger" + r.operationID = "test_response_integer" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixNullable" - r.operationID = "test_request_string_unix_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUnixNullableArray" - r.operationID = "test_request_string_unix_nullable_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseIntegerArray" + r.operationID = "test_response_integer_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUnixNullableArrayArray - r.name = "TestRequestStringUnixNullableArrayArray" - r.operationID = "test_request_string_unix_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - } + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerArrayArray + r.name = "TestResponseIntegerArrayArray" + r.operationID = "test_response_integer_array_array" + r.args = args + r.count = 0 + return r, true + default: + return } } - case 'r': // Prefix: "ri" - if l := len("ri"); len(elem) >= l && elem[0:l] == "ri" { + } + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { elem = elem[l:] } else { break @@ -24846,8 +27404,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringURI" - r.operationID = "test_request_string_uri" + r.name = "TestResponseIntegerInt32" + r.operationID = "test_response_integer_int32" r.args = args r.count = 0 return r, true @@ -24877,8 +27435,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringURIArray" - r.operationID = "test_request_string_uri_array" + r.name = "TestResponseIntegerInt32Array" + r.operationID = "test_response_integer_int32_array" r.args = args r.count = 0 return r, true @@ -24897,9 +27455,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestStringURIArrayArray - r.name = "TestRequestStringURIArrayArray" - r.operationID = "test_request_string_uri_array_array" + // Leaf: TestResponseIntegerInt32ArrayArray + r.name = "TestResponseIntegerInt32ArrayArray" + r.operationID = "test_response_integer_int32_array_array" r.args = args r.count = 0 return r, true @@ -24918,8 +27476,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringURINullable" - r.operationID = "test_request_string_uri_nullable" + r.name = "TestResponseIntegerInt32Nullable" + r.operationID = "test_response_integer_int32_nullable" r.args = args r.count = 0 return r, true @@ -24938,8 +27496,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringURINullableArray" - r.operationID = "test_request_string_uri_nullable_array" + r.name = "TestResponseIntegerInt32NullableArray" + r.operationID = "test_response_integer_int32_nullable_array" r.args = args r.count = 0 return r, true @@ -24958,9 +27516,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestStringURINullableArrayArray - r.name = "TestRequestStringURINullableArrayArray" - r.operationID = "test_request_string_uri_nullable_array_array" + // Leaf: TestResponseIntegerInt32NullableArrayArray + r.name = "TestResponseIntegerInt32NullableArrayArray" + r.operationID = "test_response_integer_int32_nullable_array_array" r.args = args r.count = 0 return r, true @@ -24972,8 +27530,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - case 'u': // Prefix: "uid" - if l := len("uid"); len(elem) >= l && elem[0:l] == "uid" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break @@ -24982,8 +27540,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUUID" - r.operationID = "test_request_string_uuid" + r.name = "TestResponseIntegerInt64" + r.operationID = "test_response_integer_int64" r.args = args r.count = 0 return r, true @@ -25013,8 +27571,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestRequestStringUUIDArray" - r.operationID = "test_request_string_uuid_array" + r.name = "TestResponseIntegerInt64Array" + r.operationID = "test_response_integer_int64_array" r.args = args r.count = 0 return r, true @@ -25033,9 +27591,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestRequestStringUUIDArrayArray - r.name = "TestRequestStringUUIDArrayArray" - r.operationID = "test_request_string_uuid_array_array" + // Leaf: TestResponseIntegerInt64ArrayArray + r.name = "TestResponseIntegerInt64ArrayArray" + r.operationID = "test_response_integer_int64_array_array" r.args = args r.count = 0 return r, true @@ -25052,206 +27610,60 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUUIDNullable" - r.operationID = "test_request_string_uuid_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestRequestStringUUIDNullableArray" - r.operationID = "test_request_string_uuid_nullable_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestRequestStringUUIDNullableArrayArray - r.name = "TestRequestStringUUIDNullableArrayArray" - r.operationID = "test_request_string_uuid_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - } - } - } - } - } - } - } - case 's': // Prefix: "sponse_" - if l := len("sponse_"); len(elem) >= l && elem[0:l] == "sponse_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'A': // Prefix: "Any" - if l := len("Any"); len(elem) >= l && elem[0:l] == "Any" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestResponseAny - r.name = "TestResponseAny" - r.operationID = "test_response_Any" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - case 'E': // Prefix: "EmptyStruct" - if l := len("EmptyStruct"); len(elem) >= l && elem[0:l] == "EmptyStruct" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestResponseEmptyStruct - r.name = "TestResponseEmptyStruct" - r.operationID = "test_response_EmptyStruct" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - case 'F': // Prefix: "FormatTest" - if l := len("FormatTest"); len(elem) >= l && elem[0:l] == "FormatTest" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestResponseFormatTest - r.name = "TestResponseFormatTest" - r.operationID = "test_response_FormatTest" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - case 'b': // Prefix: "boolean" - if l := len("boolean"); len(elem) >= l && elem[0:l] == "boolean" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseBoolean" - r.operationID = "test_response_boolean" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { - elem = elem[l:] - } else { - break - } + switch method { + case "POST": + r.name = "TestResponseIntegerInt64Nullable" + r.operationID = "test_response_integer_int64_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseBooleanArray" - r.operationID = "test_response_boolean_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseIntegerInt64NullableArray" + r.operationID = "test_response_integer_int64_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestResponseBooleanArrayArray - r.name = "TestResponseBooleanArrayArray" - r.operationID = "test_response_boolean_array_array" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerInt64NullableArrayArray + r.name = "TestResponseIntegerInt64NullableArrayArray" + r.operationID = "test_response_integer_int64_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } } } } @@ -25265,8 +27677,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseBooleanNullable" - r.operationID = "test_response_boolean_nullable" + r.name = "TestResponseIntegerNullable" + r.operationID = "test_response_integer_nullable" r.args = args r.count = 0 return r, true @@ -25285,8 +27697,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseBooleanNullableArray" - r.operationID = "test_response_boolean_nullable_array" + r.name = "TestResponseIntegerNullableArray" + r.operationID = "test_response_integer_nullable_array" r.args = args r.count = 0 return r, true @@ -25305,9 +27717,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseBooleanNullableArrayArray - r.name = "TestResponseBooleanNullableArrayArray" - r.operationID = "test_response_boolean_nullable_array_array" + // Leaf: TestResponseIntegerNullableArrayArray + r.name = "TestResponseIntegerNullableArrayArray" + r.operationID = "test_response_integer_nullable_array_array" r.args = args r.count = 0 return r, true @@ -25317,61 +27729,19 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - } - } - case 'i': // Prefix: "integer" - if l := len("integer"); len(elem) >= l && elem[0:l] == "integer" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseInteger" - r.operationID = "test_response_integer" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case 'u': // Prefix: "u" + if l := len("u"); len(elem) >= l && elem[0:l] == "u" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerArray" - r.operationID = "test_response_integer_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'i': // Prefix: "int" + if l := len("int"); len(elem) >= l && elem[0:l] == "int" { elem = elem[l:] } else { break @@ -25380,9 +27750,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerArrayArray - r.name = "TestResponseIntegerArrayArray" - r.operationID = "test_response_integer_array_array" + r.name = "TestResponseIntegerUint" + r.operationID = "test_response_integer_uint" r.args = args r.count = 0 return r, true @@ -25390,71 +27759,176 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'i': // Prefix: "int" - if l := len("int"); len(elem) >= l && elem[0:l] == "int" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '3': // Prefix: "32" + if l := len("32"); len(elem) >= l && elem[0:l] == "32" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '3': // Prefix: "32" - if l := len("32"); len(elem) >= l && elem[0:l] == "32" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseIntegerUint32" + r.operationID = "test_response_integer_uint32" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseIntegerUint32Array" + r.operationID = "test_response_integer_uint32_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUint32ArrayArray + r.name = "TestResponseIntegerUint32ArrayArray" + r.operationID = "test_response_integer_uint32_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseIntegerUint32Nullable" + r.operationID = "test_response_integer_uint32_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerInt32" - r.operationID = "test_response_integer_int32" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseIntegerUint32NullableArray" + r.operationID = "test_response_integer_uint32_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUint32NullableArrayArray + r.name = "TestResponseIntegerUint32NullableArrayArray" + r.operationID = "test_response_integer_uint32_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } + } + } } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case '6': // Prefix: "64" + if l := len("64"); len(elem) >= l && elem[0:l] == "64" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestResponseIntegerUint64" + r.operationID = "test_response_integer_uint64" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerInt32Array" - r.operationID = "test_response_integer_int32_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -25463,9 +27937,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerInt32ArrayArray - r.name = "TestResponseIntegerInt32ArrayArray" - r.operationID = "test_response_integer_int32_array_array" + r.name = "TestResponseIntegerUint64Array" + r.operationID = "test_response_integer_uint64_array" r.args = args r.count = 0 return r, true @@ -25473,29 +27946,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerInt32Nullable" - r.operationID = "test_response_integer_int32_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUint64ArrayArray + r.name = "TestResponseIntegerUint64ArrayArray" + r.operationID = "test_response_integer_uint64_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -25504,8 +27978,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerInt32NullableArray" - r.operationID = "test_response_integer_int32_nullable_array" + r.name = "TestResponseIntegerUint64Nullable" + r.operationID = "test_response_integer_uint64_nullable" r.args = args r.count = 0 return r, true @@ -25524,9 +27998,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerInt32NullableArrayArray - r.name = "TestResponseIntegerInt32NullableArrayArray" - r.operationID = "test_response_integer_int32_nullable_array_array" + r.name = "TestResponseIntegerUint64NullableArray" + r.operationID = "test_response_integer_uint64_nullable_array" r.args = args r.count = 0 return r, true @@ -25534,30 +28007,31 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUint64NullableArrayArray + r.name = "TestResponseIntegerUint64NullableArrayArray" + r.operationID = "test_response_integer_uint64_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } - } - case '6': // Prefix: "64" - if l := len("64"); len(elem) >= l && elem[0:l] == "64" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerInt64" - r.operationID = "test_response_integer_int64" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { case '_': // Prefix: "_" if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] @@ -25579,8 +28053,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerInt64Array" - r.operationID = "test_response_integer_int64_array" + r.name = "TestResponseIntegerUintArray" + r.operationID = "test_response_integer_uint_array" r.args = args r.count = 0 return r, true @@ -25599,9 +28073,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerInt64ArrayArray - r.name = "TestResponseIntegerInt64ArrayArray" - r.operationID = "test_response_integer_int64_array_array" + // Leaf: TestResponseIntegerUintArrayArray + r.name = "TestResponseIntegerUintArrayArray" + r.operationID = "test_response_integer_uint_array_array" r.args = args r.count = 0 return r, true @@ -25620,8 +28094,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerInt64Nullable" - r.operationID = "test_response_integer_int64_nullable" + r.name = "TestResponseIntegerUintNullable" + r.operationID = "test_response_integer_uint_nullable" r.args = args r.count = 0 return r, true @@ -25640,8 +28114,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerInt64NullableArray" - r.operationID = "test_response_integer_int64_nullable_array" + r.name = "TestResponseIntegerUintNullableArray" + r.operationID = "test_response_integer_uint_nullable_array" r.args = args r.count = 0 return r, true @@ -25660,9 +28134,9 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerInt64NullableArrayArray - r.name = "TestResponseIntegerInt64NullableArrayArray" - r.operationID = "test_response_integer_int64_nullable_array_array" + // Leaf: TestResponseIntegerUintNullableArrayArray + r.name = "TestResponseIntegerUintNullableArrayArray" + r.operationID = "test_response_integer_uint_nullable_array_array" r.args = args r.count = 0 return r, true @@ -25674,29 +28148,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { } } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerNullable" - r.operationID = "test_response_integer_nullable" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nix" + if l := len("nix"); len(elem) >= l && elem[0:l] == "nix" { elem = elem[l:] } else { break @@ -25705,71 +28158,18 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerNullableArray" - r.operationID = "test_response_integer_nullable_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - // Leaf: TestResponseIntegerNullableArrayArray - r.name = "TestResponseIntegerNullableArrayArray" - r.operationID = "test_response_integer_nullable_array_array" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - } - } - case 'u': // Prefix: "unix" - if l := len("unix"); len(elem) >= l && elem[0:l] == "unix" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnix" - r.operationID = "test_response_integer_unix" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '-': // Prefix: "-" - if l := len("-"); len(elem) >= l && elem[0:l] == "-" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break + r.name = "TestResponseIntegerUnix" + r.operationID = "test_response_integer_unix" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'm': // Prefix: "mi" - if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { + case '-': // Prefix: "-" + if l := len("-"); len(elem) >= l && elem[0:l] == "-" { elem = elem[l:] } else { break @@ -25779,59 +28179,50 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { break } switch elem[0] { - case 'c': // Prefix: "cro" - if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { + case 'm': // Prefix: "mi" + if l := len("mi"); len(elem) >= l && elem[0:l] == "mi" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixMicro" - r.operationID = "test_response_integer_unix-micro" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'c': // Prefix: "cro" + if l := len("cro"); len(elem) >= l && elem[0:l] == "cro" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestResponseIntegerUnixMicro" + r.operationID = "test_response_integer_unix-micro" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixMicroArray" - r.operationID = "test_response_integer_unix-micro_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -25840,9 +28231,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixMicroArrayArray - r.name = "TestResponseIntegerUnixMicroArrayArray" - r.operationID = "test_response_integer_unix-micro_array_array" + r.name = "TestResponseIntegerUnixMicroArray" + r.operationID = "test_response_integer_unix-micro_array" r.args = args r.count = 0 return r, true @@ -25850,29 +28240,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixMicroNullable" - r.operationID = "test_response_integer_unix-micro_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixMicroArrayArray + r.name = "TestResponseIntegerUnixMicroArrayArray" + r.operationID = "test_response_integer_unix-micro_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -25881,8 +28272,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerUnixMicroNullableArray" - r.operationID = "test_response_integer_unix-micro_nullable_array" + r.name = "TestResponseIntegerUnixMicroNullable" + r.operationID = "test_response_integer_unix-micro_nullable" r.args = args r.count = 0 return r, true @@ -25901,9 +28292,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixMicroNullableArrayArray - r.name = "TestResponseIntegerUnixMicroNullableArrayArray" - r.operationID = "test_response_integer_unix-micro_nullable_array_array" + r.name = "TestResponseIntegerUnixMicroNullableArray" + r.operationID = "test_response_integer_unix-micro_nullable_array" r.args = args r.count = 0 return r, true @@ -25911,63 +28301,64 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixMicroNullableArrayArray + r.name = "TestResponseIntegerUnixMicroNullableArrayArray" + r.operationID = "test_response_integer_unix-micro_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } - } - case 'l': // Prefix: "lli" - if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixMilli" - r.operationID = "test_response_integer_unix-milli" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'l': // Prefix: "lli" + if l := len("lli"); len(elem) >= l && elem[0:l] == "lli" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestResponseIntegerUnixMilli" + r.operationID = "test_response_integer_unix-milli" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixMilliArray" - r.operationID = "test_response_integer_unix-milli_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -25976,9 +28367,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixMilliArrayArray - r.name = "TestResponseIntegerUnixMilliArrayArray" - r.operationID = "test_response_integer_unix-milli_array_array" + r.name = "TestResponseIntegerUnixMilliArray" + r.operationID = "test_response_integer_unix-milli_array" r.args = args r.count = 0 return r, true @@ -25986,29 +28376,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixMilliNullable" - r.operationID = "test_response_integer_unix-milli_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixMilliArrayArray + r.name = "TestResponseIntegerUnixMilliArrayArray" + r.operationID = "test_response_integer_unix-milli_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -26017,8 +28408,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerUnixMilliNullableArray" - r.operationID = "test_response_integer_unix-milli_nullable_array" + r.name = "TestResponseIntegerUnixMilliNullable" + r.operationID = "test_response_integer_unix-milli_nullable" r.args = args r.count = 0 return r, true @@ -26037,9 +28428,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixMilliNullableArrayArray - r.name = "TestResponseIntegerUnixMilliNullableArrayArray" - r.operationID = "test_response_integer_unix-milli_nullable_array_array" + r.name = "TestResponseIntegerUnixMilliNullableArray" + r.operationID = "test_response_integer_unix-milli_nullable_array" r.args = args r.count = 0 return r, true @@ -26047,64 +28437,65 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixMilliNullableArrayArray + r.name = "TestResponseIntegerUnixMilliNullableArrayArray" + r.operationID = "test_response_integer_unix-milli_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } } - } - case 'n': // Prefix: "nano" - if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixNano" - r.operationID = "test_response_integer_unix-nano" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 'n': // Prefix: "nano" + if l := len("nano"); len(elem) >= l && elem[0:l] == "nano" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestResponseIntegerUnixNano" + r.operationID = "test_response_integer_unix-nano" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixNanoArray" - r.operationID = "test_response_integer_unix-nano_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break + } + + if len(elem) == 0 { + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -26113,9 +28504,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixNanoArrayArray - r.name = "TestResponseIntegerUnixNanoArrayArray" - r.operationID = "test_response_integer_unix-nano_array_array" + r.name = "TestResponseIntegerUnixNanoArray" + r.operationID = "test_response_integer_unix-nano_array" r.args = args r.count = 0 return r, true @@ -26123,29 +28513,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixNanoNullable" - r.operationID = "test_response_integer_unix-nano_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixNanoArrayArray + r.name = "TestResponseIntegerUnixNanoArrayArray" + r.operationID = "test_response_integer_unix-nano_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -26154,8 +28545,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerUnixNanoNullableArray" - r.operationID = "test_response_integer_unix-nano_nullable_array" + r.name = "TestResponseIntegerUnixNanoNullable" + r.operationID = "test_response_integer_unix-nano_nullable" r.args = args r.count = 0 return r, true @@ -26174,9 +28565,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixNanoNullableArrayArray - r.name = "TestResponseIntegerUnixNanoNullableArrayArray" - r.operationID = "test_response_integer_unix-nano_nullable_array_array" + r.name = "TestResponseIntegerUnixNanoNullableArray" + r.operationID = "test_response_integer_unix-nano_nullable_array" r.args = args r.count = 0 return r, true @@ -26184,63 +28574,64 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixNanoNullableArrayArray + r.name = "TestResponseIntegerUnixNanoNullableArrayArray" + r.operationID = "test_response_integer_unix-nano_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } - } - case 's': // Prefix: "seconds" - if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixSeconds" - r.operationID = "test_response_integer_unix-seconds" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + case 's': // Prefix: "seconds" + if l := len("seconds"); len(elem) >= l && elem[0:l] == "seconds" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "POST": + r.name = "TestResponseIntegerUnixSeconds" + r.operationID = "test_response_integer_unix-seconds" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixSecondsArray" - r.operationID = "test_response_integer_unix-seconds_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -26249,9 +28640,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixSecondsArrayArray - r.name = "TestResponseIntegerUnixSecondsArrayArray" - r.operationID = "test_response_integer_unix-seconds_array_array" + r.name = "TestResponseIntegerUnixSecondsArray" + r.operationID = "test_response_integer_unix-seconds_array" r.args = args r.count = 0 return r, true @@ -26259,29 +28649,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixSecondsNullable" - r.operationID = "test_response_integer_unix-seconds_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixSecondsArrayArray + r.name = "TestResponseIntegerUnixSecondsArrayArray" + r.operationID = "test_response_integer_unix-seconds_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -26290,8 +28681,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerUnixSecondsNullableArray" - r.operationID = "test_response_integer_unix-seconds_nullable_array" + r.name = "TestResponseIntegerUnixSecondsNullable" + r.operationID = "test_response_integer_unix-seconds_nullable" r.args = args r.count = 0 return r, true @@ -26310,9 +28701,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixSecondsNullableArrayArray - r.name = "TestResponseIntegerUnixSecondsNullableArrayArray" - r.operationID = "test_response_integer_unix-seconds_nullable_array_array" + r.name = "TestResponseIntegerUnixSecondsNullableArray" + r.operationID = "test_response_integer_unix-seconds_nullable_array" r.args = args r.count = 0 return r, true @@ -26320,44 +28710,45 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixSecondsNullableArrayArray + r.name = "TestResponseIntegerUnixSecondsNullableArrayArray" + r.operationID = "test_response_integer_unix-seconds_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } } - } - case '_': // Prefix: "_" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "array" - if l := len("array"); len(elem) >= l && elem[0:l] == "array" { + case '_': // Prefix: "_" + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixArray" - r.operationID = "test_response_integer_unix_array" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'a': // Prefix: "array" + if l := len("array"); len(elem) >= l && elem[0:l] == "array" { elem = elem[l:] } else { break @@ -26366,9 +28757,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixArrayArray - r.name = "TestResponseIntegerUnixArrayArray" - r.operationID = "test_response_integer_unix_array_array" + r.name = "TestResponseIntegerUnixArray" + r.operationID = "test_response_integer_unix_array" r.args = args r.count = 0 return r, true @@ -26376,29 +28766,30 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } - } - case 'n': // Prefix: "nullable" - if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { - elem = elem[l:] - } else { - break - } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch method { - case "POST": - r.name = "TestResponseIntegerUnixNullable" - r.operationID = "test_response_integer_unix_nullable" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixArrayArray + r.name = "TestResponseIntegerUnixArrayArray" + r.operationID = "test_response_integer_unix_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } } - } - switch elem[0] { - case '_': // Prefix: "_array" - if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + case 'n': // Prefix: "nullable" + if l := len("nullable"); len(elem) >= l && elem[0:l] == "nullable" { elem = elem[l:] } else { break @@ -26407,8 +28798,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - r.name = "TestResponseIntegerUnixNullableArray" - r.operationID = "test_response_integer_unix_nullable_array" + r.name = "TestResponseIntegerUnixNullable" + r.operationID = "test_response_integer_unix_nullable" r.args = args r.count = 0 return r, true @@ -26427,9 +28818,8 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { if len(elem) == 0 { switch method { case "POST": - // Leaf: TestResponseIntegerUnixNullableArrayArray - r.name = "TestResponseIntegerUnixNullableArrayArray" - r.operationID = "test_response_integer_unix_nullable_array_array" + r.name = "TestResponseIntegerUnixNullableArray" + r.operationID = "test_response_integer_unix_nullable_array" r.args = args r.count = 0 return r, true @@ -26437,6 +28827,28 @@ func (s *Server) FindRoute(method, path string) (r Route, _ bool) { return } } + switch elem[0] { + case '_': // Prefix: "_array" + if l := len("_array"); len(elem) >= l && elem[0:l] == "_array" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + // Leaf: TestResponseIntegerUnixNullableArrayArray + r.name = "TestResponseIntegerUnixNullableArrayArray" + r.operationID = "test_response_integer_unix_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + } } } } diff --git a/examples/ex_test_format/oas_schemas_gen.go b/examples/ex_test_format/oas_schemas_gen.go index 773865145..4844ac057 100644 --- a/examples/ex_test_format/oas_schemas_gen.go +++ b/examples/ex_test_format/oas_schemas_gen.go @@ -853,6 +853,120 @@ func (o NilUUID) Or(d uuid.UUID) uuid.UUID { return d } +// NewNilUint returns new NilUint with value set to v. +func NewNilUint(v uint) NilUint { + return NilUint{ + Value: v, + } +} + +// NilUint is nullable uint. +type NilUint struct { + Value uint + Null bool +} + +// SetTo sets value to v. +func (o *NilUint) SetTo(v uint) { + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o NilUint) IsNull() bool { return o.Null } + +// Get returns value and boolean that denotes whether value was set. +func (o NilUint) Get() (v uint, ok bool) { + if o.Null { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o NilUint) Or(d uint) uint { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewNilUint32 returns new NilUint32 with value set to v. +func NewNilUint32(v uint32) NilUint32 { + return NilUint32{ + Value: v, + } +} + +// NilUint32 is nullable uint32. +type NilUint32 struct { + Value uint32 + Null bool +} + +// SetTo sets value to v. +func (o *NilUint32) SetTo(v uint32) { + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o NilUint32) IsNull() bool { return o.Null } + +// Get returns value and boolean that denotes whether value was set. +func (o NilUint32) Get() (v uint32, ok bool) { + if o.Null { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o NilUint32) Or(d uint32) uint32 { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewNilUint64 returns new NilUint64 with value set to v. +func NewNilUint64(v uint64) NilUint64 { + return NilUint64{ + Value: v, + } +} + +// NilUint64 is nullable uint64. +type NilUint64 struct { + Value uint64 + Null bool +} + +// SetTo sets value to v. +func (o *NilUint64) SetTo(v uint64) { + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o NilUint64) IsNull() bool { return o.Null } + +// Get returns value and boolean that denotes whether value was set. +func (o NilUint64) Get() (v uint64, ok bool) { + if o.Null { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o NilUint64) Or(d uint64) uint64 { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewNilUnixMicro returns new NilUnixMicro with value set to v. func NewNilUnixMicro(v time.Time) NilUnixMicro { return NilUnixMicro{ @@ -2822,6 +2936,171 @@ func (o OptNilUUID) Or(d uuid.UUID) uuid.UUID { return d } +// NewOptNilUint returns new OptNilUint with value set to v. +func NewOptNilUint(v uint) OptNilUint { + return OptNilUint{ + Value: v, + Set: true, + } +} + +// OptNilUint is optional nullable uint. +type OptNilUint struct { + Value uint + Set bool + Null bool +} + +// IsSet returns true if OptNilUint was set. +func (o OptNilUint) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptNilUint) Reset() { + var v uint + o.Value = v + o.Set = false + o.Null = false +} + +// SetTo sets value to v. +func (o *OptNilUint) SetTo(v uint) { + o.Set = true + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o OptNilUint) IsNull() bool { return o.Null } + +// Get returns value and boolean that denotes whether value was set. +func (o OptNilUint) Get() (v uint, ok bool) { + if o.Null { + return v, false + } + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptNilUint) Or(d uint) uint { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptNilUint32 returns new OptNilUint32 with value set to v. +func NewOptNilUint32(v uint32) OptNilUint32 { + return OptNilUint32{ + Value: v, + Set: true, + } +} + +// OptNilUint32 is optional nullable uint32. +type OptNilUint32 struct { + Value uint32 + Set bool + Null bool +} + +// IsSet returns true if OptNilUint32 was set. +func (o OptNilUint32) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptNilUint32) Reset() { + var v uint32 + o.Value = v + o.Set = false + o.Null = false +} + +// SetTo sets value to v. +func (o *OptNilUint32) SetTo(v uint32) { + o.Set = true + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o OptNilUint32) IsNull() bool { return o.Null } + +// Get returns value and boolean that denotes whether value was set. +func (o OptNilUint32) Get() (v uint32, ok bool) { + if o.Null { + return v, false + } + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptNilUint32) Or(d uint32) uint32 { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptNilUint64 returns new OptNilUint64 with value set to v. +func NewOptNilUint64(v uint64) OptNilUint64 { + return OptNilUint64{ + Value: v, + Set: true, + } +} + +// OptNilUint64 is optional nullable uint64. +type OptNilUint64 struct { + Value uint64 + Set bool + Null bool +} + +// IsSet returns true if OptNilUint64 was set. +func (o OptNilUint64) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptNilUint64) Reset() { + var v uint64 + o.Value = v + o.Set = false + o.Null = false +} + +// SetTo sets value to v. +func (o *OptNilUint64) SetTo(v uint64) { + o.Set = true + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o OptNilUint64) IsNull() bool { return o.Null } + +// Get returns value and boolean that denotes whether value was set. +func (o OptNilUint64) Get() (v uint64, ok bool) { + if o.Null { + return v, false + } + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptNilUint64) Or(d uint64) uint64 { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptNilUnixMicro returns new OptNilUnixMicro with value set to v. func NewOptNilUnixMicro(v time.Time) OptNilUnixMicro { return OptNilUnixMicro{ @@ -3594,6 +3873,144 @@ func (o OptUUID) Or(d uuid.UUID) uuid.UUID { return d } +// NewOptUint returns new OptUint with value set to v. +func NewOptUint(v uint) OptUint { + return OptUint{ + Value: v, + Set: true, + } +} + +// OptUint is optional uint. +type OptUint struct { + Value uint + Set bool +} + +// IsSet returns true if OptUint was set. +func (o OptUint) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptUint) Reset() { + var v uint + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptUint) SetTo(v uint) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptUint) Get() (v uint, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptUint) Or(d uint) uint { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptUint32 returns new OptUint32 with value set to v. +func NewOptUint32(v uint32) OptUint32 { + return OptUint32{ + Value: v, + Set: true, + } +} + +// OptUint32 is optional uint32. +type OptUint32 struct { + Value uint32 + Set bool +} + +// IsSet returns true if OptUint32 was set. +func (o OptUint32) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptUint32) Reset() { + var v uint32 + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptUint32) SetTo(v uint32) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptUint32) Get() (v uint32, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptUint32) Or(d uint32) uint32 { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptUint64 returns new OptUint64 with value set to v. +func NewOptUint64(v uint64) OptUint64 { + return OptUint64{ + Value: v, + Set: true, + } +} + +// OptUint64 is optional uint64. +type OptUint64 struct { + Value uint64 + Set bool +} + +// IsSet returns true if OptUint64 was set. +func (o OptUint64) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptUint64) Reset() { + var v uint64 + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptUint64) SetTo(v uint64) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptUint64) Get() (v uint64, ok bool) { + if !o.Set { + return v, false + } + return o.Value, true +} + +// Or returns value if set, or given parameter if does not. +func (o OptUint64) Or(d uint64) uint64 { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptUnixMicro returns new OptUnixMicro with value set to v. func NewOptUnixMicro(v time.Time) OptUnixMicro { return OptUnixMicro{ @@ -3787,6 +4204,9 @@ type TestRequestFormatTestReq struct { RequiredArrayInteger []int "json:\"required_array_integer\"" RequiredArrayIntegerInt32 []int32 "json:\"required_array_integer_int32\"" RequiredArrayIntegerInt64 []int64 "json:\"required_array_integer_int64\"" + RequiredArrayIntegerUint []uint "json:\"required_array_integer_uint\"" + RequiredArrayIntegerUint32 []uint32 "json:\"required_array_integer_uint32\"" + RequiredArrayIntegerUint64 []uint64 "json:\"required_array_integer_uint64\"" RequiredArrayIntegerUnix []time.Time "json:\"required_array_integer_unix\"" RequiredArrayIntegerUnixMinusMicro []time.Time "json:\"required_array_integer_unix-micro\"" RequiredArrayIntegerUnixMinusMilli []time.Time "json:\"required_array_integer_unix-milli\"" @@ -3826,6 +4246,9 @@ type TestRequestFormatTestReq struct { RequiredDoubleArrayInteger [][]int "json:\"required_double_array_integer\"" RequiredDoubleArrayIntegerInt32 [][]int32 "json:\"required_double_array_integer_int32\"" RequiredDoubleArrayIntegerInt64 [][]int64 "json:\"required_double_array_integer_int64\"" + RequiredDoubleArrayIntegerUint [][]uint "json:\"required_double_array_integer_uint\"" + RequiredDoubleArrayIntegerUint32 [][]uint32 "json:\"required_double_array_integer_uint32\"" + RequiredDoubleArrayIntegerUint64 [][]uint64 "json:\"required_double_array_integer_uint64\"" RequiredDoubleArrayIntegerUnix [][]time.Time "json:\"required_double_array_integer_unix\"" RequiredDoubleArrayIntegerUnixMinusMicro [][]time.Time "json:\"required_double_array_integer_unix-micro\"" RequiredDoubleArrayIntegerUnixMinusMilli [][]time.Time "json:\"required_double_array_integer_unix-milli\"" @@ -3862,6 +4285,9 @@ type TestRequestFormatTestReq struct { RequiredInteger int "json:\"required_integer\"" RequiredIntegerInt32 int32 "json:\"required_integer_int32\"" RequiredIntegerInt64 int64 "json:\"required_integer_int64\"" + RequiredIntegerUint uint "json:\"required_integer_uint\"" + RequiredIntegerUint32 uint32 "json:\"required_integer_uint32\"" + RequiredIntegerUint64 uint64 "json:\"required_integer_uint64\"" RequiredIntegerUnix time.Time "json:\"required_integer_unix\"" RequiredIntegerUnixMinusMicro time.Time "json:\"required_integer_unix-micro\"" RequiredIntegerUnixMinusMilli time.Time "json:\"required_integer_unix-milli\"" @@ -3901,6 +4327,9 @@ type TestRequestFormatTestReq struct { OptionalArrayInteger []int "json:\"optional_array_integer\"" OptionalArrayIntegerInt32 []int32 "json:\"optional_array_integer_int32\"" OptionalArrayIntegerInt64 []int64 "json:\"optional_array_integer_int64\"" + OptionalArrayIntegerUint []uint "json:\"optional_array_integer_uint\"" + OptionalArrayIntegerUint32 []uint32 "json:\"optional_array_integer_uint32\"" + OptionalArrayIntegerUint64 []uint64 "json:\"optional_array_integer_uint64\"" OptionalArrayIntegerUnix []time.Time "json:\"optional_array_integer_unix\"" OptionalArrayIntegerUnixMinusMicro []time.Time "json:\"optional_array_integer_unix-micro\"" OptionalArrayIntegerUnixMinusMilli []time.Time "json:\"optional_array_integer_unix-milli\"" @@ -3940,6 +4369,9 @@ type TestRequestFormatTestReq struct { OptionalDoubleArrayInteger [][]int "json:\"optional_double_array_integer\"" OptionalDoubleArrayIntegerInt32 [][]int32 "json:\"optional_double_array_integer_int32\"" OptionalDoubleArrayIntegerInt64 [][]int64 "json:\"optional_double_array_integer_int64\"" + OptionalDoubleArrayIntegerUint [][]uint "json:\"optional_double_array_integer_uint\"" + OptionalDoubleArrayIntegerUint32 [][]uint32 "json:\"optional_double_array_integer_uint32\"" + OptionalDoubleArrayIntegerUint64 [][]uint64 "json:\"optional_double_array_integer_uint64\"" OptionalDoubleArrayIntegerUnix [][]time.Time "json:\"optional_double_array_integer_unix\"" OptionalDoubleArrayIntegerUnixMinusMicro [][]time.Time "json:\"optional_double_array_integer_unix-micro\"" OptionalDoubleArrayIntegerUnixMinusMilli [][]time.Time "json:\"optional_double_array_integer_unix-milli\"" @@ -3976,6 +4408,9 @@ type TestRequestFormatTestReq struct { OptionalInteger OptInt "json:\"optional_integer\"" OptionalIntegerInt32 OptInt32 "json:\"optional_integer_int32\"" OptionalIntegerInt64 OptInt64 "json:\"optional_integer_int64\"" + OptionalIntegerUint OptUint "json:\"optional_integer_uint\"" + OptionalIntegerUint32 OptUint32 "json:\"optional_integer_uint32\"" + OptionalIntegerUint64 OptUint64 "json:\"optional_integer_uint64\"" OptionalIntegerUnix OptUnixSeconds "json:\"optional_integer_unix\"" OptionalIntegerUnixMinusMicro OptUnixMicro "json:\"optional_integer_unix-micro\"" OptionalIntegerUnixMinusMilli OptUnixMilli "json:\"optional_integer_unix-milli\"" @@ -4020,6 +4455,9 @@ type TestRequestRequiredFormatTestReq struct { RequiredArrayInteger []int "json:\"required_array_integer\"" RequiredArrayIntegerInt32 []int32 "json:\"required_array_integer_int32\"" RequiredArrayIntegerInt64 []int64 "json:\"required_array_integer_int64\"" + RequiredArrayIntegerUint []uint "json:\"required_array_integer_uint\"" + RequiredArrayIntegerUint32 []uint32 "json:\"required_array_integer_uint32\"" + RequiredArrayIntegerUint64 []uint64 "json:\"required_array_integer_uint64\"" RequiredArrayIntegerUnix []time.Time "json:\"required_array_integer_unix\"" RequiredArrayIntegerUnixMinusMicro []time.Time "json:\"required_array_integer_unix-micro\"" RequiredArrayIntegerUnixMinusMilli []time.Time "json:\"required_array_integer_unix-milli\"" @@ -4059,6 +4497,9 @@ type TestRequestRequiredFormatTestReq struct { RequiredDoubleArrayInteger [][]int "json:\"required_double_array_integer\"" RequiredDoubleArrayIntegerInt32 [][]int32 "json:\"required_double_array_integer_int32\"" RequiredDoubleArrayIntegerInt64 [][]int64 "json:\"required_double_array_integer_int64\"" + RequiredDoubleArrayIntegerUint [][]uint "json:\"required_double_array_integer_uint\"" + RequiredDoubleArrayIntegerUint32 [][]uint32 "json:\"required_double_array_integer_uint32\"" + RequiredDoubleArrayIntegerUint64 [][]uint64 "json:\"required_double_array_integer_uint64\"" RequiredDoubleArrayIntegerUnix [][]time.Time "json:\"required_double_array_integer_unix\"" RequiredDoubleArrayIntegerUnixMinusMicro [][]time.Time "json:\"required_double_array_integer_unix-micro\"" RequiredDoubleArrayIntegerUnixMinusMilli [][]time.Time "json:\"required_double_array_integer_unix-milli\"" @@ -4095,6 +4536,9 @@ type TestRequestRequiredFormatTestReq struct { RequiredInteger int "json:\"required_integer\"" RequiredIntegerInt32 int32 "json:\"required_integer_int32\"" RequiredIntegerInt64 int64 "json:\"required_integer_int64\"" + RequiredIntegerUint uint "json:\"required_integer_uint\"" + RequiredIntegerUint32 uint32 "json:\"required_integer_uint32\"" + RequiredIntegerUint64 uint64 "json:\"required_integer_uint64\"" RequiredIntegerUnix time.Time "json:\"required_integer_unix\"" RequiredIntegerUnixMinusMicro time.Time "json:\"required_integer_unix-micro\"" RequiredIntegerUnixMinusMilli time.Time "json:\"required_integer_unix-milli\"" @@ -4134,6 +4578,9 @@ type TestRequestRequiredFormatTestReq struct { OptionalArrayInteger []int "json:\"optional_array_integer\"" OptionalArrayIntegerInt32 []int32 "json:\"optional_array_integer_int32\"" OptionalArrayIntegerInt64 []int64 "json:\"optional_array_integer_int64\"" + OptionalArrayIntegerUint []uint "json:\"optional_array_integer_uint\"" + OptionalArrayIntegerUint32 []uint32 "json:\"optional_array_integer_uint32\"" + OptionalArrayIntegerUint64 []uint64 "json:\"optional_array_integer_uint64\"" OptionalArrayIntegerUnix []time.Time "json:\"optional_array_integer_unix\"" OptionalArrayIntegerUnixMinusMicro []time.Time "json:\"optional_array_integer_unix-micro\"" OptionalArrayIntegerUnixMinusMilli []time.Time "json:\"optional_array_integer_unix-milli\"" @@ -4173,6 +4620,9 @@ type TestRequestRequiredFormatTestReq struct { OptionalDoubleArrayInteger [][]int "json:\"optional_double_array_integer\"" OptionalDoubleArrayIntegerInt32 [][]int32 "json:\"optional_double_array_integer_int32\"" OptionalDoubleArrayIntegerInt64 [][]int64 "json:\"optional_double_array_integer_int64\"" + OptionalDoubleArrayIntegerUint [][]uint "json:\"optional_double_array_integer_uint\"" + OptionalDoubleArrayIntegerUint32 [][]uint32 "json:\"optional_double_array_integer_uint32\"" + OptionalDoubleArrayIntegerUint64 [][]uint64 "json:\"optional_double_array_integer_uint64\"" OptionalDoubleArrayIntegerUnix [][]time.Time "json:\"optional_double_array_integer_unix\"" OptionalDoubleArrayIntegerUnixMinusMicro [][]time.Time "json:\"optional_double_array_integer_unix-micro\"" OptionalDoubleArrayIntegerUnixMinusMilli [][]time.Time "json:\"optional_double_array_integer_unix-milli\"" @@ -4209,6 +4659,9 @@ type TestRequestRequiredFormatTestReq struct { OptionalInteger OptInt "json:\"optional_integer\"" OptionalIntegerInt32 OptInt32 "json:\"optional_integer_int32\"" OptionalIntegerInt64 OptInt64 "json:\"optional_integer_int64\"" + OptionalIntegerUint OptUint "json:\"optional_integer_uint\"" + OptionalIntegerUint32 OptUint32 "json:\"optional_integer_uint32\"" + OptionalIntegerUint64 OptUint64 "json:\"optional_integer_uint64\"" OptionalIntegerUnix OptUnixSeconds "json:\"optional_integer_unix\"" OptionalIntegerUnixMinusMicro OptUnixMicro "json:\"optional_integer_unix-micro\"" OptionalIntegerUnixMinusMilli OptUnixMilli "json:\"optional_integer_unix-milli\"" @@ -4253,6 +4706,9 @@ type TestResponseFormatTestOK struct { RequiredArrayInteger []int "json:\"required_array_integer\"" RequiredArrayIntegerInt32 []int32 "json:\"required_array_integer_int32\"" RequiredArrayIntegerInt64 []int64 "json:\"required_array_integer_int64\"" + RequiredArrayIntegerUint []uint "json:\"required_array_integer_uint\"" + RequiredArrayIntegerUint32 []uint32 "json:\"required_array_integer_uint32\"" + RequiredArrayIntegerUint64 []uint64 "json:\"required_array_integer_uint64\"" RequiredArrayIntegerUnix []time.Time "json:\"required_array_integer_unix\"" RequiredArrayIntegerUnixMinusMicro []time.Time "json:\"required_array_integer_unix-micro\"" RequiredArrayIntegerUnixMinusMilli []time.Time "json:\"required_array_integer_unix-milli\"" @@ -4292,6 +4748,9 @@ type TestResponseFormatTestOK struct { RequiredDoubleArrayInteger [][]int "json:\"required_double_array_integer\"" RequiredDoubleArrayIntegerInt32 [][]int32 "json:\"required_double_array_integer_int32\"" RequiredDoubleArrayIntegerInt64 [][]int64 "json:\"required_double_array_integer_int64\"" + RequiredDoubleArrayIntegerUint [][]uint "json:\"required_double_array_integer_uint\"" + RequiredDoubleArrayIntegerUint32 [][]uint32 "json:\"required_double_array_integer_uint32\"" + RequiredDoubleArrayIntegerUint64 [][]uint64 "json:\"required_double_array_integer_uint64\"" RequiredDoubleArrayIntegerUnix [][]time.Time "json:\"required_double_array_integer_unix\"" RequiredDoubleArrayIntegerUnixMinusMicro [][]time.Time "json:\"required_double_array_integer_unix-micro\"" RequiredDoubleArrayIntegerUnixMinusMilli [][]time.Time "json:\"required_double_array_integer_unix-milli\"" @@ -4328,6 +4787,9 @@ type TestResponseFormatTestOK struct { RequiredInteger int "json:\"required_integer\"" RequiredIntegerInt32 int32 "json:\"required_integer_int32\"" RequiredIntegerInt64 int64 "json:\"required_integer_int64\"" + RequiredIntegerUint uint "json:\"required_integer_uint\"" + RequiredIntegerUint32 uint32 "json:\"required_integer_uint32\"" + RequiredIntegerUint64 uint64 "json:\"required_integer_uint64\"" RequiredIntegerUnix time.Time "json:\"required_integer_unix\"" RequiredIntegerUnixMinusMicro time.Time "json:\"required_integer_unix-micro\"" RequiredIntegerUnixMinusMilli time.Time "json:\"required_integer_unix-milli\"" @@ -4367,6 +4829,9 @@ type TestResponseFormatTestOK struct { OptionalArrayInteger []int "json:\"optional_array_integer\"" OptionalArrayIntegerInt32 []int32 "json:\"optional_array_integer_int32\"" OptionalArrayIntegerInt64 []int64 "json:\"optional_array_integer_int64\"" + OptionalArrayIntegerUint []uint "json:\"optional_array_integer_uint\"" + OptionalArrayIntegerUint32 []uint32 "json:\"optional_array_integer_uint32\"" + OptionalArrayIntegerUint64 []uint64 "json:\"optional_array_integer_uint64\"" OptionalArrayIntegerUnix []time.Time "json:\"optional_array_integer_unix\"" OptionalArrayIntegerUnixMinusMicro []time.Time "json:\"optional_array_integer_unix-micro\"" OptionalArrayIntegerUnixMinusMilli []time.Time "json:\"optional_array_integer_unix-milli\"" @@ -4406,6 +4871,9 @@ type TestResponseFormatTestOK struct { OptionalDoubleArrayInteger [][]int "json:\"optional_double_array_integer\"" OptionalDoubleArrayIntegerInt32 [][]int32 "json:\"optional_double_array_integer_int32\"" OptionalDoubleArrayIntegerInt64 [][]int64 "json:\"optional_double_array_integer_int64\"" + OptionalDoubleArrayIntegerUint [][]uint "json:\"optional_double_array_integer_uint\"" + OptionalDoubleArrayIntegerUint32 [][]uint32 "json:\"optional_double_array_integer_uint32\"" + OptionalDoubleArrayIntegerUint64 [][]uint64 "json:\"optional_double_array_integer_uint64\"" OptionalDoubleArrayIntegerUnix [][]time.Time "json:\"optional_double_array_integer_unix\"" OptionalDoubleArrayIntegerUnixMinusMicro [][]time.Time "json:\"optional_double_array_integer_unix-micro\"" OptionalDoubleArrayIntegerUnixMinusMilli [][]time.Time "json:\"optional_double_array_integer_unix-milli\"" @@ -4442,6 +4910,9 @@ type TestResponseFormatTestOK struct { OptionalInteger OptInt "json:\"optional_integer\"" OptionalIntegerInt32 OptInt32 "json:\"optional_integer_int32\"" OptionalIntegerInt64 OptInt64 "json:\"optional_integer_int64\"" + OptionalIntegerUint OptUint "json:\"optional_integer_uint\"" + OptionalIntegerUint32 OptUint32 "json:\"optional_integer_uint32\"" + OptionalIntegerUint64 OptUint64 "json:\"optional_integer_uint64\"" OptionalIntegerUnix OptUnixSeconds "json:\"optional_integer_unix\"" OptionalIntegerUnixMinusMicro OptUnixMicro "json:\"optional_integer_unix-micro\"" OptionalIntegerUnixMinusMilli OptUnixMilli "json:\"optional_integer_unix-milli\"" diff --git a/examples/ex_test_format/oas_server_gen.go b/examples/ex_test_format/oas_server_gen.go index 3e1992cc9..d528fa2b4 100644 --- a/examples/ex_test_format/oas_server_gen.go +++ b/examples/ex_test_format/oas_server_gen.go @@ -129,6 +129,78 @@ type Handler interface { // // POST /test_request_integer_nullable_array_array TestRequestIntegerNullableArrayArray(ctx context.Context, req [][]NilInt) (Error, error) + // TestRequestIntegerUint implements test_request_integer_uint operation. + // + // POST /test_request_integer_uint + TestRequestIntegerUint(ctx context.Context, req OptUint) (Error, error) + // TestRequestIntegerUint32 implements test_request_integer_uint32 operation. + // + // POST /test_request_integer_uint32 + TestRequestIntegerUint32(ctx context.Context, req OptUint32) (Error, error) + // TestRequestIntegerUint32Array implements test_request_integer_uint32_array operation. + // + // POST /test_request_integer_uint32_array + TestRequestIntegerUint32Array(ctx context.Context, req []uint32) (Error, error) + // TestRequestIntegerUint32ArrayArray implements test_request_integer_uint32_array_array operation. + // + // POST /test_request_integer_uint32_array_array + TestRequestIntegerUint32ArrayArray(ctx context.Context, req [][]uint32) (Error, error) + // TestRequestIntegerUint32Nullable implements test_request_integer_uint32_nullable operation. + // + // POST /test_request_integer_uint32_nullable + TestRequestIntegerUint32Nullable(ctx context.Context, req OptNilUint32) (Error, error) + // TestRequestIntegerUint32NullableArray implements test_request_integer_uint32_nullable_array operation. + // + // POST /test_request_integer_uint32_nullable_array + TestRequestIntegerUint32NullableArray(ctx context.Context, req []NilUint32) (Error, error) + // TestRequestIntegerUint32NullableArrayArray implements test_request_integer_uint32_nullable_array_array operation. + // + // POST /test_request_integer_uint32_nullable_array_array + TestRequestIntegerUint32NullableArrayArray(ctx context.Context, req [][]NilUint32) (Error, error) + // TestRequestIntegerUint64 implements test_request_integer_uint64 operation. + // + // POST /test_request_integer_uint64 + TestRequestIntegerUint64(ctx context.Context, req OptUint64) (Error, error) + // TestRequestIntegerUint64Array implements test_request_integer_uint64_array operation. + // + // POST /test_request_integer_uint64_array + TestRequestIntegerUint64Array(ctx context.Context, req []uint64) (Error, error) + // TestRequestIntegerUint64ArrayArray implements test_request_integer_uint64_array_array operation. + // + // POST /test_request_integer_uint64_array_array + TestRequestIntegerUint64ArrayArray(ctx context.Context, req [][]uint64) (Error, error) + // TestRequestIntegerUint64Nullable implements test_request_integer_uint64_nullable operation. + // + // POST /test_request_integer_uint64_nullable + TestRequestIntegerUint64Nullable(ctx context.Context, req OptNilUint64) (Error, error) + // TestRequestIntegerUint64NullableArray implements test_request_integer_uint64_nullable_array operation. + // + // POST /test_request_integer_uint64_nullable_array + TestRequestIntegerUint64NullableArray(ctx context.Context, req []NilUint64) (Error, error) + // TestRequestIntegerUint64NullableArrayArray implements test_request_integer_uint64_nullable_array_array operation. + // + // POST /test_request_integer_uint64_nullable_array_array + TestRequestIntegerUint64NullableArrayArray(ctx context.Context, req [][]NilUint64) (Error, error) + // TestRequestIntegerUintArray implements test_request_integer_uint_array operation. + // + // POST /test_request_integer_uint_array + TestRequestIntegerUintArray(ctx context.Context, req []uint) (Error, error) + // TestRequestIntegerUintArrayArray implements test_request_integer_uint_array_array operation. + // + // POST /test_request_integer_uint_array_array + TestRequestIntegerUintArrayArray(ctx context.Context, req [][]uint) (Error, error) + // TestRequestIntegerUintNullable implements test_request_integer_uint_nullable operation. + // + // POST /test_request_integer_uint_nullable + TestRequestIntegerUintNullable(ctx context.Context, req OptNilUint) (Error, error) + // TestRequestIntegerUintNullableArray implements test_request_integer_uint_nullable_array operation. + // + // POST /test_request_integer_uint_nullable_array + TestRequestIntegerUintNullableArray(ctx context.Context, req []NilUint) (Error, error) + // TestRequestIntegerUintNullableArrayArray implements test_request_integer_uint_nullable_array_array operation. + // + // POST /test_request_integer_uint_nullable_array_array + TestRequestIntegerUintNullableArrayArray(ctx context.Context, req [][]NilUint) (Error, error) // TestRequestIntegerUnix implements test_request_integer_unix operation. // // POST /test_request_integer_unix @@ -501,6 +573,78 @@ type Handler interface { // // POST /test_request_required_integer_nullable_array_array TestRequestRequiredIntegerNullableArrayArray(ctx context.Context, req [][]NilInt) (Error, error) + // TestRequestRequiredIntegerUint implements test_request_required_integer_uint operation. + // + // POST /test_request_required_integer_uint + TestRequestRequiredIntegerUint(ctx context.Context, req uint) (Error, error) + // TestRequestRequiredIntegerUint32 implements test_request_required_integer_uint32 operation. + // + // POST /test_request_required_integer_uint32 + TestRequestRequiredIntegerUint32(ctx context.Context, req uint32) (Error, error) + // TestRequestRequiredIntegerUint32Array implements test_request_required_integer_uint32_array operation. + // + // POST /test_request_required_integer_uint32_array + TestRequestRequiredIntegerUint32Array(ctx context.Context, req []uint32) (Error, error) + // TestRequestRequiredIntegerUint32ArrayArray implements test_request_required_integer_uint32_array_array operation. + // + // POST /test_request_required_integer_uint32_array_array + TestRequestRequiredIntegerUint32ArrayArray(ctx context.Context, req [][]uint32) (Error, error) + // TestRequestRequiredIntegerUint32Nullable implements test_request_required_integer_uint32_nullable operation. + // + // POST /test_request_required_integer_uint32_nullable + TestRequestRequiredIntegerUint32Nullable(ctx context.Context, req NilUint32) (Error, error) + // TestRequestRequiredIntegerUint32NullableArray implements test_request_required_integer_uint32_nullable_array operation. + // + // POST /test_request_required_integer_uint32_nullable_array + TestRequestRequiredIntegerUint32NullableArray(ctx context.Context, req []NilUint32) (Error, error) + // TestRequestRequiredIntegerUint32NullableArrayArray implements test_request_required_integer_uint32_nullable_array_array operation. + // + // POST /test_request_required_integer_uint32_nullable_array_array + TestRequestRequiredIntegerUint32NullableArrayArray(ctx context.Context, req [][]NilUint32) (Error, error) + // TestRequestRequiredIntegerUint64 implements test_request_required_integer_uint64 operation. + // + // POST /test_request_required_integer_uint64 + TestRequestRequiredIntegerUint64(ctx context.Context, req uint64) (Error, error) + // TestRequestRequiredIntegerUint64Array implements test_request_required_integer_uint64_array operation. + // + // POST /test_request_required_integer_uint64_array + TestRequestRequiredIntegerUint64Array(ctx context.Context, req []uint64) (Error, error) + // TestRequestRequiredIntegerUint64ArrayArray implements test_request_required_integer_uint64_array_array operation. + // + // POST /test_request_required_integer_uint64_array_array + TestRequestRequiredIntegerUint64ArrayArray(ctx context.Context, req [][]uint64) (Error, error) + // TestRequestRequiredIntegerUint64Nullable implements test_request_required_integer_uint64_nullable operation. + // + // POST /test_request_required_integer_uint64_nullable + TestRequestRequiredIntegerUint64Nullable(ctx context.Context, req NilUint64) (Error, error) + // TestRequestRequiredIntegerUint64NullableArray implements test_request_required_integer_uint64_nullable_array operation. + // + // POST /test_request_required_integer_uint64_nullable_array + TestRequestRequiredIntegerUint64NullableArray(ctx context.Context, req []NilUint64) (Error, error) + // TestRequestRequiredIntegerUint64NullableArrayArray implements test_request_required_integer_uint64_nullable_array_array operation. + // + // POST /test_request_required_integer_uint64_nullable_array_array + TestRequestRequiredIntegerUint64NullableArrayArray(ctx context.Context, req [][]NilUint64) (Error, error) + // TestRequestRequiredIntegerUintArray implements test_request_required_integer_uint_array operation. + // + // POST /test_request_required_integer_uint_array + TestRequestRequiredIntegerUintArray(ctx context.Context, req []uint) (Error, error) + // TestRequestRequiredIntegerUintArrayArray implements test_request_required_integer_uint_array_array operation. + // + // POST /test_request_required_integer_uint_array_array + TestRequestRequiredIntegerUintArrayArray(ctx context.Context, req [][]uint) (Error, error) + // TestRequestRequiredIntegerUintNullable implements test_request_required_integer_uint_nullable operation. + // + // POST /test_request_required_integer_uint_nullable + TestRequestRequiredIntegerUintNullable(ctx context.Context, req NilUint) (Error, error) + // TestRequestRequiredIntegerUintNullableArray implements test_request_required_integer_uint_nullable_array operation. + // + // POST /test_request_required_integer_uint_nullable_array + TestRequestRequiredIntegerUintNullableArray(ctx context.Context, req []NilUint) (Error, error) + // TestRequestRequiredIntegerUintNullableArrayArray implements test_request_required_integer_uint_nullable_array_array operation. + // + // POST /test_request_required_integer_uint_nullable_array_array + TestRequestRequiredIntegerUintNullableArrayArray(ctx context.Context, req [][]NilUint) (Error, error) // TestRequestRequiredIntegerUnix implements test_request_required_integer_unix operation. // // POST /test_request_required_integer_unix @@ -1929,6 +2073,78 @@ type Handler interface { // // POST /test_response_integer_nullable_array_array TestResponseIntegerNullableArrayArray(ctx context.Context, req string) ([][]NilInt, error) + // TestResponseIntegerUint implements test_response_integer_uint operation. + // + // POST /test_response_integer_uint + TestResponseIntegerUint(ctx context.Context, req string) (uint, error) + // TestResponseIntegerUint32 implements test_response_integer_uint32 operation. + // + // POST /test_response_integer_uint32 + TestResponseIntegerUint32(ctx context.Context, req string) (uint32, error) + // TestResponseIntegerUint32Array implements test_response_integer_uint32_array operation. + // + // POST /test_response_integer_uint32_array + TestResponseIntegerUint32Array(ctx context.Context, req string) ([]uint32, error) + // TestResponseIntegerUint32ArrayArray implements test_response_integer_uint32_array_array operation. + // + // POST /test_response_integer_uint32_array_array + TestResponseIntegerUint32ArrayArray(ctx context.Context, req string) ([][]uint32, error) + // TestResponseIntegerUint32Nullable implements test_response_integer_uint32_nullable operation. + // + // POST /test_response_integer_uint32_nullable + TestResponseIntegerUint32Nullable(ctx context.Context, req string) (NilUint32, error) + // TestResponseIntegerUint32NullableArray implements test_response_integer_uint32_nullable_array operation. + // + // POST /test_response_integer_uint32_nullable_array + TestResponseIntegerUint32NullableArray(ctx context.Context, req string) ([]NilUint32, error) + // TestResponseIntegerUint32NullableArrayArray implements test_response_integer_uint32_nullable_array_array operation. + // + // POST /test_response_integer_uint32_nullable_array_array + TestResponseIntegerUint32NullableArrayArray(ctx context.Context, req string) ([][]NilUint32, error) + // TestResponseIntegerUint64 implements test_response_integer_uint64 operation. + // + // POST /test_response_integer_uint64 + TestResponseIntegerUint64(ctx context.Context, req string) (uint64, error) + // TestResponseIntegerUint64Array implements test_response_integer_uint64_array operation. + // + // POST /test_response_integer_uint64_array + TestResponseIntegerUint64Array(ctx context.Context, req string) ([]uint64, error) + // TestResponseIntegerUint64ArrayArray implements test_response_integer_uint64_array_array operation. + // + // POST /test_response_integer_uint64_array_array + TestResponseIntegerUint64ArrayArray(ctx context.Context, req string) ([][]uint64, error) + // TestResponseIntegerUint64Nullable implements test_response_integer_uint64_nullable operation. + // + // POST /test_response_integer_uint64_nullable + TestResponseIntegerUint64Nullable(ctx context.Context, req string) (NilUint64, error) + // TestResponseIntegerUint64NullableArray implements test_response_integer_uint64_nullable_array operation. + // + // POST /test_response_integer_uint64_nullable_array + TestResponseIntegerUint64NullableArray(ctx context.Context, req string) ([]NilUint64, error) + // TestResponseIntegerUint64NullableArrayArray implements test_response_integer_uint64_nullable_array_array operation. + // + // POST /test_response_integer_uint64_nullable_array_array + TestResponseIntegerUint64NullableArrayArray(ctx context.Context, req string) ([][]NilUint64, error) + // TestResponseIntegerUintArray implements test_response_integer_uint_array operation. + // + // POST /test_response_integer_uint_array + TestResponseIntegerUintArray(ctx context.Context, req string) ([]uint, error) + // TestResponseIntegerUintArrayArray implements test_response_integer_uint_array_array operation. + // + // POST /test_response_integer_uint_array_array + TestResponseIntegerUintArrayArray(ctx context.Context, req string) ([][]uint, error) + // TestResponseIntegerUintNullable implements test_response_integer_uint_nullable operation. + // + // POST /test_response_integer_uint_nullable + TestResponseIntegerUintNullable(ctx context.Context, req string) (NilUint, error) + // TestResponseIntegerUintNullableArray implements test_response_integer_uint_nullable_array operation. + // + // POST /test_response_integer_uint_nullable_array + TestResponseIntegerUintNullableArray(ctx context.Context, req string) ([]NilUint, error) + // TestResponseIntegerUintNullableArrayArray implements test_response_integer_uint_nullable_array_array operation. + // + // POST /test_response_integer_uint_nullable_array_array + TestResponseIntegerUintNullableArrayArray(ctx context.Context, req string) ([][]NilUint, error) // TestResponseIntegerUnix implements test_response_integer_unix operation. // // POST /test_response_integer_unix diff --git a/examples/ex_test_format/oas_unimplemented_gen.go b/examples/ex_test_format/oas_unimplemented_gen.go index 33cc122f4..98db90aab 100644 --- a/examples/ex_test_format/oas_unimplemented_gen.go +++ b/examples/ex_test_format/oas_unimplemented_gen.go @@ -215,6 +215,132 @@ func (UnimplementedHandler) TestRequestIntegerNullableArrayArray(ctx context.Con return r, ht.ErrNotImplemented } +// TestRequestIntegerUint implements test_request_integer_uint operation. +// +// POST /test_request_integer_uint +func (UnimplementedHandler) TestRequestIntegerUint(ctx context.Context, req OptUint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint32 implements test_request_integer_uint32 operation. +// +// POST /test_request_integer_uint32 +func (UnimplementedHandler) TestRequestIntegerUint32(ctx context.Context, req OptUint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint32Array implements test_request_integer_uint32_array operation. +// +// POST /test_request_integer_uint32_array +func (UnimplementedHandler) TestRequestIntegerUint32Array(ctx context.Context, req []uint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint32ArrayArray implements test_request_integer_uint32_array_array operation. +// +// POST /test_request_integer_uint32_array_array +func (UnimplementedHandler) TestRequestIntegerUint32ArrayArray(ctx context.Context, req [][]uint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint32Nullable implements test_request_integer_uint32_nullable operation. +// +// POST /test_request_integer_uint32_nullable +func (UnimplementedHandler) TestRequestIntegerUint32Nullable(ctx context.Context, req OptNilUint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint32NullableArray implements test_request_integer_uint32_nullable_array operation. +// +// POST /test_request_integer_uint32_nullable_array +func (UnimplementedHandler) TestRequestIntegerUint32NullableArray(ctx context.Context, req []NilUint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint32NullableArrayArray implements test_request_integer_uint32_nullable_array_array operation. +// +// POST /test_request_integer_uint32_nullable_array_array +func (UnimplementedHandler) TestRequestIntegerUint32NullableArrayArray(ctx context.Context, req [][]NilUint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint64 implements test_request_integer_uint64 operation. +// +// POST /test_request_integer_uint64 +func (UnimplementedHandler) TestRequestIntegerUint64(ctx context.Context, req OptUint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint64Array implements test_request_integer_uint64_array operation. +// +// POST /test_request_integer_uint64_array +func (UnimplementedHandler) TestRequestIntegerUint64Array(ctx context.Context, req []uint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint64ArrayArray implements test_request_integer_uint64_array_array operation. +// +// POST /test_request_integer_uint64_array_array +func (UnimplementedHandler) TestRequestIntegerUint64ArrayArray(ctx context.Context, req [][]uint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint64Nullable implements test_request_integer_uint64_nullable operation. +// +// POST /test_request_integer_uint64_nullable +func (UnimplementedHandler) TestRequestIntegerUint64Nullable(ctx context.Context, req OptNilUint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint64NullableArray implements test_request_integer_uint64_nullable_array operation. +// +// POST /test_request_integer_uint64_nullable_array +func (UnimplementedHandler) TestRequestIntegerUint64NullableArray(ctx context.Context, req []NilUint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUint64NullableArrayArray implements test_request_integer_uint64_nullable_array_array operation. +// +// POST /test_request_integer_uint64_nullable_array_array +func (UnimplementedHandler) TestRequestIntegerUint64NullableArrayArray(ctx context.Context, req [][]NilUint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUintArray implements test_request_integer_uint_array operation. +// +// POST /test_request_integer_uint_array +func (UnimplementedHandler) TestRequestIntegerUintArray(ctx context.Context, req []uint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUintArrayArray implements test_request_integer_uint_array_array operation. +// +// POST /test_request_integer_uint_array_array +func (UnimplementedHandler) TestRequestIntegerUintArrayArray(ctx context.Context, req [][]uint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUintNullable implements test_request_integer_uint_nullable operation. +// +// POST /test_request_integer_uint_nullable +func (UnimplementedHandler) TestRequestIntegerUintNullable(ctx context.Context, req OptNilUint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUintNullableArray implements test_request_integer_uint_nullable_array operation. +// +// POST /test_request_integer_uint_nullable_array +func (UnimplementedHandler) TestRequestIntegerUintNullableArray(ctx context.Context, req []NilUint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestIntegerUintNullableArrayArray implements test_request_integer_uint_nullable_array_array operation. +// +// POST /test_request_integer_uint_nullable_array_array +func (UnimplementedHandler) TestRequestIntegerUintNullableArrayArray(ctx context.Context, req [][]NilUint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + // TestRequestIntegerUnix implements test_request_integer_unix operation. // // POST /test_request_integer_unix @@ -866,6 +992,132 @@ func (UnimplementedHandler) TestRequestRequiredIntegerNullableArrayArray(ctx con return r, ht.ErrNotImplemented } +// TestRequestRequiredIntegerUint implements test_request_required_integer_uint operation. +// +// POST /test_request_required_integer_uint +func (UnimplementedHandler) TestRequestRequiredIntegerUint(ctx context.Context, req uint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint32 implements test_request_required_integer_uint32 operation. +// +// POST /test_request_required_integer_uint32 +func (UnimplementedHandler) TestRequestRequiredIntegerUint32(ctx context.Context, req uint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint32Array implements test_request_required_integer_uint32_array operation. +// +// POST /test_request_required_integer_uint32_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint32Array(ctx context.Context, req []uint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint32ArrayArray implements test_request_required_integer_uint32_array_array operation. +// +// POST /test_request_required_integer_uint32_array_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint32ArrayArray(ctx context.Context, req [][]uint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint32Nullable implements test_request_required_integer_uint32_nullable operation. +// +// POST /test_request_required_integer_uint32_nullable +func (UnimplementedHandler) TestRequestRequiredIntegerUint32Nullable(ctx context.Context, req NilUint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint32NullableArray implements test_request_required_integer_uint32_nullable_array operation. +// +// POST /test_request_required_integer_uint32_nullable_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint32NullableArray(ctx context.Context, req []NilUint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint32NullableArrayArray implements test_request_required_integer_uint32_nullable_array_array operation. +// +// POST /test_request_required_integer_uint32_nullable_array_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint32NullableArrayArray(ctx context.Context, req [][]NilUint32) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint64 implements test_request_required_integer_uint64 operation. +// +// POST /test_request_required_integer_uint64 +func (UnimplementedHandler) TestRequestRequiredIntegerUint64(ctx context.Context, req uint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint64Array implements test_request_required_integer_uint64_array operation. +// +// POST /test_request_required_integer_uint64_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint64Array(ctx context.Context, req []uint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint64ArrayArray implements test_request_required_integer_uint64_array_array operation. +// +// POST /test_request_required_integer_uint64_array_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint64ArrayArray(ctx context.Context, req [][]uint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint64Nullable implements test_request_required_integer_uint64_nullable operation. +// +// POST /test_request_required_integer_uint64_nullable +func (UnimplementedHandler) TestRequestRequiredIntegerUint64Nullable(ctx context.Context, req NilUint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint64NullableArray implements test_request_required_integer_uint64_nullable_array operation. +// +// POST /test_request_required_integer_uint64_nullable_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint64NullableArray(ctx context.Context, req []NilUint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUint64NullableArrayArray implements test_request_required_integer_uint64_nullable_array_array operation. +// +// POST /test_request_required_integer_uint64_nullable_array_array +func (UnimplementedHandler) TestRequestRequiredIntegerUint64NullableArrayArray(ctx context.Context, req [][]NilUint64) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUintArray implements test_request_required_integer_uint_array operation. +// +// POST /test_request_required_integer_uint_array +func (UnimplementedHandler) TestRequestRequiredIntegerUintArray(ctx context.Context, req []uint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUintArrayArray implements test_request_required_integer_uint_array_array operation. +// +// POST /test_request_required_integer_uint_array_array +func (UnimplementedHandler) TestRequestRequiredIntegerUintArrayArray(ctx context.Context, req [][]uint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUintNullable implements test_request_required_integer_uint_nullable operation. +// +// POST /test_request_required_integer_uint_nullable +func (UnimplementedHandler) TestRequestRequiredIntegerUintNullable(ctx context.Context, req NilUint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUintNullableArray implements test_request_required_integer_uint_nullable_array operation. +// +// POST /test_request_required_integer_uint_nullable_array +func (UnimplementedHandler) TestRequestRequiredIntegerUintNullableArray(ctx context.Context, req []NilUint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredIntegerUintNullableArrayArray implements test_request_required_integer_uint_nullable_array_array operation. +// +// POST /test_request_required_integer_uint_nullable_array_array +func (UnimplementedHandler) TestRequestRequiredIntegerUintNullableArrayArray(ctx context.Context, req [][]NilUint) (r Error, _ error) { + return r, ht.ErrNotImplemented +} + // TestRequestRequiredIntegerUnix implements test_request_required_integer_unix operation. // // POST /test_request_required_integer_unix @@ -3365,6 +3617,132 @@ func (UnimplementedHandler) TestResponseIntegerNullableArrayArray(ctx context.Co return r, ht.ErrNotImplemented } +// TestResponseIntegerUint implements test_response_integer_uint operation. +// +// POST /test_response_integer_uint +func (UnimplementedHandler) TestResponseIntegerUint(ctx context.Context, req string) (r uint, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint32 implements test_response_integer_uint32 operation. +// +// POST /test_response_integer_uint32 +func (UnimplementedHandler) TestResponseIntegerUint32(ctx context.Context, req string) (r uint32, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint32Array implements test_response_integer_uint32_array operation. +// +// POST /test_response_integer_uint32_array +func (UnimplementedHandler) TestResponseIntegerUint32Array(ctx context.Context, req string) (r []uint32, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint32ArrayArray implements test_response_integer_uint32_array_array operation. +// +// POST /test_response_integer_uint32_array_array +func (UnimplementedHandler) TestResponseIntegerUint32ArrayArray(ctx context.Context, req string) (r [][]uint32, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint32Nullable implements test_response_integer_uint32_nullable operation. +// +// POST /test_response_integer_uint32_nullable +func (UnimplementedHandler) TestResponseIntegerUint32Nullable(ctx context.Context, req string) (r NilUint32, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint32NullableArray implements test_response_integer_uint32_nullable_array operation. +// +// POST /test_response_integer_uint32_nullable_array +func (UnimplementedHandler) TestResponseIntegerUint32NullableArray(ctx context.Context, req string) (r []NilUint32, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint32NullableArrayArray implements test_response_integer_uint32_nullable_array_array operation. +// +// POST /test_response_integer_uint32_nullable_array_array +func (UnimplementedHandler) TestResponseIntegerUint32NullableArrayArray(ctx context.Context, req string) (r [][]NilUint32, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint64 implements test_response_integer_uint64 operation. +// +// POST /test_response_integer_uint64 +func (UnimplementedHandler) TestResponseIntegerUint64(ctx context.Context, req string) (r uint64, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint64Array implements test_response_integer_uint64_array operation. +// +// POST /test_response_integer_uint64_array +func (UnimplementedHandler) TestResponseIntegerUint64Array(ctx context.Context, req string) (r []uint64, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint64ArrayArray implements test_response_integer_uint64_array_array operation. +// +// POST /test_response_integer_uint64_array_array +func (UnimplementedHandler) TestResponseIntegerUint64ArrayArray(ctx context.Context, req string) (r [][]uint64, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint64Nullable implements test_response_integer_uint64_nullable operation. +// +// POST /test_response_integer_uint64_nullable +func (UnimplementedHandler) TestResponseIntegerUint64Nullable(ctx context.Context, req string) (r NilUint64, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint64NullableArray implements test_response_integer_uint64_nullable_array operation. +// +// POST /test_response_integer_uint64_nullable_array +func (UnimplementedHandler) TestResponseIntegerUint64NullableArray(ctx context.Context, req string) (r []NilUint64, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUint64NullableArrayArray implements test_response_integer_uint64_nullable_array_array operation. +// +// POST /test_response_integer_uint64_nullable_array_array +func (UnimplementedHandler) TestResponseIntegerUint64NullableArrayArray(ctx context.Context, req string) (r [][]NilUint64, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUintArray implements test_response_integer_uint_array operation. +// +// POST /test_response_integer_uint_array +func (UnimplementedHandler) TestResponseIntegerUintArray(ctx context.Context, req string) (r []uint, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUintArrayArray implements test_response_integer_uint_array_array operation. +// +// POST /test_response_integer_uint_array_array +func (UnimplementedHandler) TestResponseIntegerUintArrayArray(ctx context.Context, req string) (r [][]uint, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUintNullable implements test_response_integer_uint_nullable operation. +// +// POST /test_response_integer_uint_nullable +func (UnimplementedHandler) TestResponseIntegerUintNullable(ctx context.Context, req string) (r NilUint, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUintNullableArray implements test_response_integer_uint_nullable_array operation. +// +// POST /test_response_integer_uint_nullable_array +func (UnimplementedHandler) TestResponseIntegerUintNullableArray(ctx context.Context, req string) (r []NilUint, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseIntegerUintNullableArrayArray implements test_response_integer_uint_nullable_array_array operation. +// +// POST /test_response_integer_uint_nullable_array_array +func (UnimplementedHandler) TestResponseIntegerUintNullableArrayArray(ctx context.Context, req string) (r [][]NilUint, _ error) { + return r, ht.ErrNotImplemented +} + // TestResponseIntegerUnix implements test_response_integer_unix operation. // // POST /test_response_integer_unix diff --git a/examples/ex_test_format/oas_validators_gen.go b/examples/ex_test_format/oas_validators_gen.go index d883bcd30..daf80b335 100644 --- a/examples/ex_test_format/oas_validators_gen.go +++ b/examples/ex_test_format/oas_validators_gen.go @@ -67,6 +67,39 @@ func (s TestRequestFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredArrayIntegerUint == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint", + Error: err, + }) + } + if err := func() error { + if s.RequiredArrayIntegerUint32 == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + if s.RequiredArrayIntegerUint64 == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint64", + Error: err, + }) + } if err := func() error { if s.RequiredArrayIntegerUnix == nil { return errors.New("nil is invalid value") @@ -671,6 +704,90 @@ func (s TestRequestFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredDoubleArrayIntegerUint == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayIntegerUint { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer_uint", + Error: err, + }) + } + if err := func() error { + if s.RequiredDoubleArrayIntegerUint32 == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayIntegerUint32 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + if s.RequiredDoubleArrayIntegerUint64 == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayIntegerUint64 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer_uint64", + Error: err, + }) + } if err := func() error { if s.RequiredDoubleArrayIntegerUnix == nil { return errors.New("nil is invalid value") @@ -2033,6 +2150,81 @@ func (s TestRequestFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint", + Error: err, + }) + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint32 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint64 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint64", + Error: err, + }) + } if err := func() error { var failures []validate.FieldError for i, elem := range s.OptionalDoubleArrayIntegerUnix { @@ -3127,6 +3319,39 @@ func (s TestRequestRequiredFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredArrayIntegerUint == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint", + Error: err, + }) + } + if err := func() error { + if s.RequiredArrayIntegerUint32 == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + if s.RequiredArrayIntegerUint64 == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint64", + Error: err, + }) + } if err := func() error { if s.RequiredArrayIntegerUnix == nil { return errors.New("nil is invalid value") @@ -3620,11 +3845,95 @@ func (s TestRequestRequiredFormatTestReq) Validate() error { }) } if err := func() error { - if s.RequiredDoubleArrayBoolean == nil { + if s.RequiredDoubleArrayBoolean == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayBoolean { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_boolean", + Error: err, + }) + } + if err := func() error { + if s.RequiredDoubleArrayInteger == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayInteger { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer", + Error: err, + }) + } + if err := func() error { + if s.RequiredDoubleArrayIntegerInt32 == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayIntegerInt32 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer_int32", + Error: err, + }) + } + if err := func() error { + if s.RequiredDoubleArrayIntegerInt64 == nil { return errors.New("nil is invalid value") } var failures []validate.FieldError - for i, elem := range s.RequiredDoubleArrayBoolean { + for i, elem := range s.RequiredDoubleArrayIntegerInt64 { if err := func() error { if elem == nil { return errors.New("nil is invalid value") @@ -3643,16 +3952,16 @@ func (s TestRequestRequiredFormatTestReq) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "required_double_array_boolean", + Name: "required_double_array_integer_int64", Error: err, }) } if err := func() error { - if s.RequiredDoubleArrayInteger == nil { + if s.RequiredDoubleArrayIntegerUint == nil { return errors.New("nil is invalid value") } var failures []validate.FieldError - for i, elem := range s.RequiredDoubleArrayInteger { + for i, elem := range s.RequiredDoubleArrayIntegerUint { if err := func() error { if elem == nil { return errors.New("nil is invalid value") @@ -3671,16 +3980,16 @@ func (s TestRequestRequiredFormatTestReq) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "required_double_array_integer", + Name: "required_double_array_integer_uint", Error: err, }) } if err := func() error { - if s.RequiredDoubleArrayIntegerInt32 == nil { + if s.RequiredDoubleArrayIntegerUint32 == nil { return errors.New("nil is invalid value") } var failures []validate.FieldError - for i, elem := range s.RequiredDoubleArrayIntegerInt32 { + for i, elem := range s.RequiredDoubleArrayIntegerUint32 { if err := func() error { if elem == nil { return errors.New("nil is invalid value") @@ -3699,16 +4008,16 @@ func (s TestRequestRequiredFormatTestReq) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "required_double_array_integer_int32", + Name: "required_double_array_integer_uint32", Error: err, }) } if err := func() error { - if s.RequiredDoubleArrayIntegerInt64 == nil { + if s.RequiredDoubleArrayIntegerUint64 == nil { return errors.New("nil is invalid value") } var failures []validate.FieldError - for i, elem := range s.RequiredDoubleArrayIntegerInt64 { + for i, elem := range s.RequiredDoubleArrayIntegerUint64 { if err := func() error { if elem == nil { return errors.New("nil is invalid value") @@ -3727,7 +4036,7 @@ func (s TestRequestRequiredFormatTestReq) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "required_double_array_integer_int64", + Name: "required_double_array_integer_uint64", Error: err, }) } @@ -5093,6 +5402,81 @@ func (s TestRequestRequiredFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint", + Error: err, + }) + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint32 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint64 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint64", + Error: err, + }) + } if err := func() error { var failures []validate.FieldError for i, elem := range s.OptionalDoubleArrayIntegerUnix { @@ -6187,6 +6571,39 @@ func (s TestResponseFormatTestOK) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredArrayIntegerUint == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint", + Error: err, + }) + } + if err := func() error { + if s.RequiredArrayIntegerUint32 == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + if s.RequiredArrayIntegerUint64 == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_integer_uint64", + Error: err, + }) + } if err := func() error { if s.RequiredArrayIntegerUnix == nil { return errors.New("nil is invalid value") @@ -6791,6 +7208,90 @@ func (s TestResponseFormatTestOK) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredDoubleArrayIntegerUint == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayIntegerUint { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer_uint", + Error: err, + }) + } + if err := func() error { + if s.RequiredDoubleArrayIntegerUint32 == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayIntegerUint32 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + if s.RequiredDoubleArrayIntegerUint64 == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayIntegerUint64 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_double_array_integer_uint64", + Error: err, + }) + } if err := func() error { if s.RequiredDoubleArrayIntegerUnix == nil { return errors.New("nil is invalid value") @@ -8153,6 +8654,81 @@ func (s TestResponseFormatTestOK) Validate() error { Error: err, }) } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint", + Error: err, + }) + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint32 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint32", + Error: err, + }) + } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayIntegerUint64 { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "optional_double_array_integer_uint64", + Error: err, + }) + } if err := func() error { var failures []validate.FieldError for i, elem := range s.OptionalDoubleArrayIntegerUnix { diff --git a/gen/ir/json.go b/gen/ir/json.go index 2ea7d3734..d87694329 100644 --- a/gen/ir/json.go +++ b/gen/ir/json.go @@ -144,7 +144,15 @@ func (j JSON) Format() string { return "IP" case "uri": return "URI" - case "int32", "int64": + case "int8", + "int16", + "int32", + "int64", + "uint", + "uint8", + "uint16", + "uint32", + "uint64": if s.Type != jsonschema.String { return "" } @@ -274,6 +282,13 @@ func (j JSON) Fn() string { return "Str" case ByteSlice: return "Base64" + case Uint, + Uint8, + Uint16, + Uint32, + Uint64: + s := j.t.Primitive.String() + return strings.ToUpper(s[:2]) + s[2:] default: return capitalize.Capitalize(j.t.Primitive.String()) } diff --git a/gen/ir/template_helpers.go b/gen/ir/template_helpers.go index acff9fd1e..8b229bda8 100644 --- a/gen/ir/template_helpers.go +++ b/gen/ir/template_helpers.go @@ -23,7 +23,10 @@ func (t *Type) EncodeFn() string { switch t.Primitive { case ByteSlice: return "Bytes" - case Int, Int64, Int32, String, Bool, Float32, Float64: + case Int, Int8, Int16, Int32, Int64, + Uint, Uint8, Uint16, Uint32, Uint64, + Float32, Float64, + String, Bool: return capitalize.Capitalize(t.Primitive.String()) case UUID, Time, IP, Duration, URL: return afterDot(t.Primitive.String()) @@ -39,7 +42,15 @@ func (t Type) uriFormat() string { return capitalize.Capitalize(f) case "date-time": return "DateTime" - case "int32", "int64": + case "int8", + "int16", + "int32", + "int64", + "uint", + "uint8", + "uint16", + "uint32", + "uint64": if s.Type != jsonschema.String { break } diff --git a/gen/schema_gen_primitive.go b/gen/schema_gen_primitive.go index 8811f99db..46f86382e 100644 --- a/gen/schema_gen_primitive.go +++ b/gen/schema_gen_primitive.go @@ -122,9 +122,17 @@ func TypeFormatMapping() map[jsonschema.SchemaType]map[string]ir.PrimitiveType { jsonschema.Integer: { "": ir.Int, - // Custom format, see https://github.com/ogen-go/ogen/issues/309. + // FIXME(tdakkota): add decoder for int8, int16, uint8, uint16 to jx. + // "int8": ir.Int8, + // "int16": ir.Int16, "int32": ir.Int32, "int64": ir.Int64, + "uint": ir.Uint, + // "uint8": ir.Uint8, + // "uint16": ir.Uint16, + "uint32": ir.Uint32, + "uint64": ir.Uint64, + // See https://github.com/ogen-go/ogen/issues/307. "unix": ir.Time, "unix-seconds": ir.Time,