From 744eb434f27d66f8e4780b4f77f891bf0db11957 Mon Sep 17 00:00:00 2001 From: Lukas Malkmus Date: Sat, 20 Jan 2024 22:23:58 +0100 Subject: [PATCH 1/6] feat: add 'mac' primitive for 'net.HardwareAddr' (MAC) --- conv/decode.go | 9 +++++ conv/encode.go | 7 ++++ gen/ir/faker.go | 2 + gen/ir/json.go | 2 +- gen/ir/primitive.go | 3 ++ gen/ir/template_helpers.go | 2 +- gen/schema_gen_primitive.go | 1 + json/mac.go | 21 ++++++++++ json/mac_test.go | 78 +++++++++++++++++++++++++++++++++++++ 9 files changed, 123 insertions(+), 2 deletions(-) create mode 100644 json/mac.go create mode 100644 json/mac_test.go diff --git a/conv/decode.go b/conv/decode.go index 452023e7e..f08700581 100644 --- a/conv/decode.go +++ b/conv/decode.go @@ -1,6 +1,7 @@ package conv import ( + "net" "net/netip" "net/url" "strconv" @@ -126,6 +127,10 @@ func ToUUID(s string) (uuid.UUID, error) { return uuid.Parse(s) } +func ToMAC(s string) (net.HardwareAddr, error) { + return net.ParseMAC(s) +} + func ToAddr(s string) (netip.Addr, error) { return netip.ParseAddr(s) } @@ -245,3 +250,7 @@ func ToBoolArray(a []string) ([]bool, error) { func ToUUIDArray(a []string) ([]uuid.UUID, error) { return decodeArray(a, ToUUID) } + +func ToMACArray(a []string) ([]net.HardwareAddr, error) { + return decodeArray(a, ToMAC) +} diff --git a/conv/encode.go b/conv/encode.go index 35e8fd851..6da331726 100644 --- a/conv/encode.go +++ b/conv/encode.go @@ -1,6 +1,7 @@ package conv import ( + "net" "net/netip" "net/url" "strconv" @@ -42,6 +43,8 @@ func DurationToString(v time.Duration) string { return v.String() } func UUIDToString(v uuid.UUID) string { return v.String() } +func MACToString(v net.HardwareAddr) string { return v.String() } + func AddrToString(v netip.Addr) string { return v.String() } func URLToString(v url.URL) string { return v.String() } @@ -104,3 +107,7 @@ func BoolArrayToString(vs []bool) []string { func UUIDArrayToString(vs []uuid.UUID) []string { return encodeArray(vs, UUIDToString) } + +func MACArrayToString(vs []net.HardwareAddr) []string { + return encodeArray(vs, MACToString) +} diff --git a/gen/ir/faker.go b/gen/ir/faker.go index 8c0561528..60c06537b 100644 --- a/gen/ir/faker.go +++ b/gen/ir/faker.go @@ -31,6 +31,8 @@ func (t *Type) FakeValue() string { return "time.Duration(5 * time.Second)" case UUID: return "uuid.New()" + case MAC: + return `net.ParseMAC("11:22:33:44:55:66")` case IP: if s := t.Schema; s != nil && s.Format == "ipv6" { return `netip.MustParseAddr("::1")` diff --git a/gen/ir/json.go b/gen/ir/json.go index 167f4f40d..64d607c5c 100644 --- a/gen/ir/json.go +++ b/gen/ir/json.go @@ -228,7 +228,7 @@ func jsonType(t *Type) string { return "Number" } return "String" - case String, Duration, UUID, IP, URL, ByteSlice: + case String, Duration, UUID, MAC, IP, URL, ByteSlice: return "String" case Null: return "Null" diff --git a/gen/ir/primitive.go b/gen/ir/primitive.go index 9fdd4e11a..1b0e0c1ee 100644 --- a/gen/ir/primitive.go +++ b/gen/ir/primitive.go @@ -44,6 +44,8 @@ func (p PrimitiveType) String() string { return "time.Duration" case UUID: return "uuid.UUID" + case MAC: + return "net.HardwareAddr" case IP: return "netip.Addr" case URL: @@ -83,6 +85,7 @@ const ( Time Duration UUID + MAC IP URL File diff --git a/gen/ir/template_helpers.go b/gen/ir/template_helpers.go index 7dc8dd178..db8a73579 100644 --- a/gen/ir/template_helpers.go +++ b/gen/ir/template_helpers.go @@ -22,7 +22,7 @@ func (t *Type) EncodeFn() string { Float32, Float64, String, Bool: return naming.Capitalize(t.Primitive.String()) - case UUID, Time, IP, Duration, URL: + case UUID, Time, MAC, IP, Duration, URL: return naming.AfterDot(t.Primitive.String()) default: return "" diff --git a/gen/schema_gen_primitive.go b/gen/schema_gen_primitive.go index 89c0a3e77..909893bfb 100644 --- a/gen/schema_gen_primitive.go +++ b/gen/schema_gen_primitive.go @@ -197,6 +197,7 @@ func TypeFormatMapping() map[jsonschema.SchemaType]map[string]ir.PrimitiveType { "time": ir.Time, "duration": ir.Duration, "uuid": ir.UUID, + "mac": ir.MAC, "ip": ir.IP, "ipv4": ir.IP, "ipv6": ir.IP, diff --git a/json/mac.go b/json/mac.go new file mode 100644 index 000000000..e94cdc2f7 --- /dev/null +++ b/json/mac.go @@ -0,0 +1,21 @@ +package json + +import ( + "net" + + "github.com/go-faster/jx" +) + +// DecodeMAC decodes net.HardwareAddr. +func DecodeMAC(d *jx.Decoder) (net.HardwareAddr, error) { + raw, err := d.Str() + if err != nil { + return nil, err + } + return net.ParseMAC(raw) +} + +// EncodeMAC encodes net.HardwareAddr. +func EncodeMAC(e *jx.Encoder, v net.HardwareAddr) { + e.Str(v.String()) +} diff --git a/json/mac_test.go b/json/mac_test.go new file mode 100644 index 000000000..e088550d2 --- /dev/null +++ b/json/mac_test.go @@ -0,0 +1,78 @@ +package json + +import ( + "fmt" + "net" + "testing" + + "github.com/go-faster/jx" + "github.com/stretchr/testify/require" +) + +func BenchmarkEncodeMAC(b *testing.B) { + mac, err := net.ParseMAC("00:11:22:33:44:55") + require.NoError(b, err) + + e := jx.GetEncoder() + // Preallocate internal buffer. + EncodeMAC(e, mac) + + b.ReportAllocs() + b.ResetTimer() + + for i := 0; i < b.N; i++ { + e.Reset() + EncodeMAC(e, mac) + } +} + +func BenchmarkDecodeMAC(b *testing.B) { + data := []byte(`"00:11:22:33:44:55"`) + d := jx.GetDecoder() + + b.ReportAllocs() + b.ResetTimer() + + var ( + mac net.HardwareAddr + err error + ) + for i := 0; i < b.N; i++ { + d.ResetBytes(data) + mac, err = DecodeMAC(d) + } + require.NoError(b, err) + _ = mac +} + +func TestMAC(t *testing.T) { + mac := func(s string) net.HardwareAddr { + m, err := net.ParseMAC(s) + require.NoError(t, err) + return m + } + tests := []struct { + input string + wantVal net.HardwareAddr + wantErr bool + }{ + // Valid MAC. + {`"00:11:22:33:44:55"`, mac("00:11:22:33:44:55"), false}, + {`"A1-B2-C3-D4-E5-F6"`, mac("A1-B2-C3-D4-E5-F6"), false}, + + // Invalid MAC. + {"01:23:45:67:89:GH", nil, true}, // GH is not a valid hex digit. + {`"00-1B-2C-3D-4E"`, nil, true}, // Too few octets. + {`"A1B2C3D4E5F6"`, nil, true}, // Missing separators. + } + for i, tt := range tests { + tt := tt + t.Run(fmt.Sprintf("Test%d", i+1), testDecodeEncode( + DecodeMAC, + EncodeMAC, + tt.input, + tt.wantVal, + tt.wantErr, + )) + } +} From d87b678700d370d8efe426db64288a0ce2703256 Mon Sep 17 00:00:00 2001 From: Lukas Malkmus Date: Wed, 24 Jan 2024 20:27:08 +0100 Subject: [PATCH 2/6] fix(json): handle mac format --- gen/ir/json.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gen/ir/json.go b/gen/ir/json.go index 64d607c5c..d6236f4bf 100644 --- a/gen/ir/json.go +++ b/gen/ir/json.go @@ -140,6 +140,8 @@ func (j JSON) Format() string { return "IPv4" case "ipv6": return "IPv6" + case "mac": + return "MAC" case "uri": return "URI" case "int", "int8", "int16", "int32", "int64", From e8c480f76204e5da20f887b5360925b3c9278cfa Mon Sep 17 00:00:00 2001 From: tdakkota Date: Tue, 6 Feb 2024 07:33:24 +0300 Subject: [PATCH 3/6] chore: commit generated files --- _testdata/positive/format_gen.json | 603 + examples/ex_test_format/oas_client_gen.go | 1424 ++ examples/ex_test_format/oas_faker_gen.go | 237 + examples/ex_test_format/oas_handlers_gen.go | 18239 +++++++++------- examples/ex_test_format/oas_json_gen.go | 3190 +-- examples/ex_test_format/oas_parameters_gen.go | 106 + .../oas_request_decoders_gen.go | 3239 ++- .../oas_request_encoders_gen.go | 321 + .../oas_response_decoders_gen.go | 2091 +- .../oas_response_encoders_gen.go | 277 + examples/ex_test_format/oas_router_gen.go | 942 + examples/ex_test_format/oas_schemas_gen.go | 353 + examples/ex_test_format/oas_server_gen.go | 73 + .../ex_test_format/oas_unimplemented_gen.go | 127 + examples/ex_test_format/oas_validators_gen.go | 192 + 15 files changed, 20430 insertions(+), 10984 deletions(-) diff --git a/_testdata/positive/format_gen.json b/_testdata/positive/format_gen.json index 339160428..702bceada 100644 --- a/_testdata/positive/format_gen.json +++ b/_testdata/positive/format_gen.json @@ -842,6 +842,27 @@ } } }, + { + "name": "string_mac", + "in": "query", + "required": true, + "schema": { + "type": "string", + "format": "mac" + } + }, + { + "name": "string_mac_array", + "in": "query", + "required": true, + "schema": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + }, { "name": "string_password", "in": "query", @@ -1482,6 +1503,13 @@ "format": "ipv6" } }, + "required_array_string_mac": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + }, "required_array_string_password": { "type": "array", "items": { @@ -1995,6 +2023,16 @@ } } }, + "required_double_array_string_mac": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + }, "required_double_array_string_password": { "type": "array", "items": { @@ -2291,6 +2329,10 @@ "type": "string", "format": "ipv6" }, + "required_string_mac": { + "type": "string", + "format": "mac" + }, "required_string_password": { "type": "string", "format": "password" @@ -2634,6 +2676,13 @@ "format": "ipv6" } }, + "optional_array_string_mac": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + }, "optional_array_string_password": { "type": "array", "items": { @@ -3147,6 +3196,16 @@ } } }, + "optional_double_array_string_mac": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + }, "optional_double_array_string_password": { "type": "array", "items": { @@ -3443,6 +3502,10 @@ "type": "string", "format": "ipv6" }, + "optional_string_mac": { + "type": "string", + "format": "mac" + }, "optional_string_password": { "type": "string", "format": "password" @@ -3544,6 +3607,7 @@ "required_array_string_ip", "required_array_string_ipv4", "required_array_string_ipv6", + "required_array_string_mac", "required_array_string_password", "required_array_string_time", "required_array_string_uint", @@ -3601,6 +3665,7 @@ "required_double_array_string_ip", "required_double_array_string_ipv4", "required_double_array_string_ipv6", + "required_double_array_string_mac", "required_double_array_string_password", "required_double_array_string_time", "required_double_array_string_uint", @@ -3655,6 +3720,7 @@ "required_string_ip", "required_string_ipv4", "required_string_ipv6", + "required_string_mac", "required_string_password", "required_string_time", "required_string_uint", @@ -7228,6 +7294,13 @@ "format": "ipv6" } }, + "required_array_string_mac": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + }, "required_array_string_password": { "type": "array", "items": { @@ -7741,6 +7814,16 @@ } } }, + "required_double_array_string_mac": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + }, "required_double_array_string_password": { "type": "array", "items": { @@ -8037,6 +8120,10 @@ "type": "string", "format": "ipv6" }, + "required_string_mac": { + "type": "string", + "format": "mac" + }, "required_string_password": { "type": "string", "format": "password" @@ -8380,6 +8467,13 @@ "format": "ipv6" } }, + "optional_array_string_mac": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + }, "optional_array_string_password": { "type": "array", "items": { @@ -8893,6 +8987,16 @@ } } }, + "optional_double_array_string_mac": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + }, "optional_double_array_string_password": { "type": "array", "items": { @@ -9189,6 +9293,10 @@ "type": "string", "format": "ipv6" }, + "optional_string_mac": { + "type": "string", + "format": "mac" + }, "optional_string_password": { "type": "string", "format": "password" @@ -9290,6 +9398,7 @@ "required_array_string_ip", "required_array_string_ipv4", "required_array_string_ipv6", + "required_array_string_mac", "required_array_string_password", "required_array_string_time", "required_array_string_uint", @@ -9347,6 +9456,7 @@ "required_double_array_string_ip", "required_double_array_string_ipv4", "required_double_array_string_ipv6", + "required_double_array_string_mac", "required_double_array_string_password", "required_double_array_string_time", "required_double_array_string_uint", @@ -9401,6 +9511,7 @@ "required_string_ip", "required_string_ipv4", "required_string_ipv6", + "required_string_mac", "required_string_password", "required_string_time", "required_string_uint", @@ -15596,6 +15707,159 @@ } } }, + "/test_request_required_string_mac": { + "post": { + "operationId": "test_request_required_string_mac", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "string", + "format": "mac" + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_string_mac_array": { + "post": { + "operationId": "test_request_required_string_mac_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_string_mac_array_array": { + "post": { + "operationId": "test_request_required_string_mac_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_string_mac_nullable": { + "post": { + "operationId": "test_request_required_string_mac_nullable", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "string", + "format": "mac", + "nullable": true + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_string_mac_nullable_array": { + "post": { + "operationId": "test_request_required_string_mac_nullable_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_required_string_mac_nullable_array_array": { + "post": { + "operationId": "test_request_required_string_mac_nullable_array_array", + "requestBody": { + "description": "Required request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + } + }, + "required": true + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, "/test_request_required_string_nullable": { "post": { "operationId": "test_request_required_string_nullable", @@ -20528,6 +20792,153 @@ } } }, + "/test_request_string_mac": { + "post": { + "operationId": "test_request_string_mac", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "string", + "format": "mac" + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_string_mac_array": { + "post": { + "operationId": "test_request_string_mac_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_string_mac_array_array": { + "post": { + "operationId": "test_request_string_mac_array_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_string_mac_nullable": { + "post": { + "operationId": "test_request_string_mac_nullable", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_string_mac_nullable_array": { + "post": { + "operationId": "test_request_string_mac_nullable_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, + "/test_request_string_mac_nullable_array_array": { + "post": { + "operationId": "test_request_string_mac_nullable_array_array", + "requestBody": { + "description": "Optional request body", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + } + } + }, + "responses": { + "200": { + "$ref": "#/components/responses/error" + } + } + } + }, "/test_request_string_nullable": { "post": { "operationId": "test_request_string_nullable", @@ -22997,6 +23408,13 @@ "format": "ipv6" } }, + "required_array_string_mac": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + }, "required_array_string_password": { "type": "array", "items": { @@ -23510,6 +23928,16 @@ } } }, + "required_double_array_string_mac": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + }, "required_double_array_string_password": { "type": "array", "items": { @@ -23806,6 +24234,10 @@ "type": "string", "format": "ipv6" }, + "required_string_mac": { + "type": "string", + "format": "mac" + }, "required_string_password": { "type": "string", "format": "password" @@ -24149,6 +24581,13 @@ "format": "ipv6" } }, + "optional_array_string_mac": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + }, "optional_array_string_password": { "type": "array", "items": { @@ -24662,6 +25101,16 @@ } } }, + "optional_double_array_string_mac": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + }, "optional_double_array_string_password": { "type": "array", "items": { @@ -24958,6 +25407,10 @@ "type": "string", "format": "ipv6" }, + "optional_string_mac": { + "type": "string", + "format": "mac" + }, "optional_string_password": { "type": "string", "format": "password" @@ -25059,6 +25512,7 @@ "required_array_string_ip", "required_array_string_ipv4", "required_array_string_ipv6", + "required_array_string_mac", "required_array_string_password", "required_array_string_time", "required_array_string_uint", @@ -25116,6 +25570,7 @@ "required_double_array_string_ip", "required_double_array_string_ipv4", "required_double_array_string_ipv6", + "required_double_array_string_mac", "required_double_array_string_password", "required_double_array_string_time", "required_double_array_string_uint", @@ -25170,6 +25625,7 @@ "required_string_ip", "required_string_ipv4", "required_string_ipv6", + "required_string_mac", "required_string_password", "required_string_time", "required_string_uint", @@ -31117,6 +31573,153 @@ } } }, + "/test_response_string_mac": { + "post": { + "operationId": "test_response_string_mac", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "string", + "format": "mac" + } + } + } + } + } + } + }, + "/test_response_string_mac_array": { + "post": { + "operationId": "test_response_string_mac_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + } + } + } + } + } + }, + "/test_response_string_mac_array_array": { + "post": { + "operationId": "test_response_string_mac_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac" + } + } + } + } + } + } + } + } + }, + "/test_response_string_mac_nullable": { + "post": { + "operationId": "test_response_string_mac_nullable", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + } + } + } + }, + "/test_response_string_mac_nullable_array": { + "post": { + "operationId": "test_response_string_mac_nullable_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + } + } + } + } + }, + "/test_response_string_mac_nullable_array_array": { + "post": { + "operationId": "test_response_string_mac_nullable_array_array", + "requestBody": { + "$ref": "#/components/requestBodies/defaultBody" + }, + "responses": { + "200": { + "description": "Response", + "content": { + "application/json": { + "schema": { + "type": "array", + "items": { + "type": "array", + "items": { + "type": "string", + "format": "mac", + "nullable": true + } + } + } + } + } + } + } + } + }, "/test_response_string_nullable": { "post": { "operationId": "test_response_string_nullable", diff --git a/examples/ex_test_format/oas_client_gen.go b/examples/ex_test_format/oas_client_gen.go index 40951cae8..2c077cb0d 100644 --- a/examples/ex_test_format/oas_client_gen.go +++ b/examples/ex_test_format/oas_client_gen.go @@ -4,6 +4,7 @@ package api import ( "context" + "net" "net/netip" "net/url" "strings" @@ -1554,6 +1555,30 @@ type Invoker interface { // // POST /test_request_required_string_ipv6_nullable_array_array TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Context, request [][]NilIPv6) (*Error, error) + // TestRequestRequiredStringMAC invokes test_request_required_string_mac operation. + // + // POST /test_request_required_string_mac + TestRequestRequiredStringMAC(ctx context.Context, request net.HardwareAddr) (*Error, error) + // TestRequestRequiredStringMACArray invokes test_request_required_string_mac_array operation. + // + // POST /test_request_required_string_mac_array + TestRequestRequiredStringMACArray(ctx context.Context, request []net.HardwareAddr) (*Error, error) + // TestRequestRequiredStringMACArrayArray invokes test_request_required_string_mac_array_array operation. + // + // POST /test_request_required_string_mac_array_array + TestRequestRequiredStringMACArrayArray(ctx context.Context, request [][]net.HardwareAddr) (*Error, error) + // TestRequestRequiredStringMACNullable invokes test_request_required_string_mac_nullable operation. + // + // POST /test_request_required_string_mac_nullable + TestRequestRequiredStringMACNullable(ctx context.Context, request NilHardwareAddr) (*Error, error) + // TestRequestRequiredStringMACNullableArray invokes test_request_required_string_mac_nullable_array operation. + // + // POST /test_request_required_string_mac_nullable_array + TestRequestRequiredStringMACNullableArray(ctx context.Context, request []NilHardwareAddr) (*Error, error) + // TestRequestRequiredStringMACNullableArrayArray invokes test_request_required_string_mac_nullable_array_array operation. + // + // POST /test_request_required_string_mac_nullable_array_array + TestRequestRequiredStringMACNullableArrayArray(ctx context.Context, request [][]NilHardwareAddr) (*Error, error) // TestRequestRequiredStringNullable invokes test_request_required_string_nullable operation. // // POST /test_request_required_string_nullable @@ -2346,6 +2371,30 @@ type Invoker interface { // // POST /test_request_string_ipv6_nullable_array_array TestRequestStringIpv6NullableArrayArray(ctx context.Context, request [][]NilIPv6) (*Error, error) + // TestRequestStringMAC invokes test_request_string_mac operation. + // + // POST /test_request_string_mac + TestRequestStringMAC(ctx context.Context, request OptHardwareAddr) (*Error, error) + // TestRequestStringMACArray invokes test_request_string_mac_array operation. + // + // POST /test_request_string_mac_array + TestRequestStringMACArray(ctx context.Context, request []net.HardwareAddr) (*Error, error) + // TestRequestStringMACArrayArray invokes test_request_string_mac_array_array operation. + // + // POST /test_request_string_mac_array_array + TestRequestStringMACArrayArray(ctx context.Context, request [][]net.HardwareAddr) (*Error, error) + // TestRequestStringMACNullable invokes test_request_string_mac_nullable operation. + // + // POST /test_request_string_mac_nullable + TestRequestStringMACNullable(ctx context.Context, request OptNilHardwareAddr) (*Error, error) + // TestRequestStringMACNullableArray invokes test_request_string_mac_nullable_array operation. + // + // POST /test_request_string_mac_nullable_array + TestRequestStringMACNullableArray(ctx context.Context, request []NilHardwareAddr) (*Error, error) + // TestRequestStringMACNullableArrayArray invokes test_request_string_mac_nullable_array_array operation. + // + // POST /test_request_string_mac_nullable_array_array + TestRequestStringMACNullableArrayArray(ctx context.Context, request [][]NilHardwareAddr) (*Error, error) // TestRequestStringNullable invokes test_request_string_nullable operation. // // POST /test_request_string_nullable @@ -3678,6 +3727,30 @@ type Invoker interface { // // POST /test_response_string_ipv6_nullable_array_array TestResponseStringIpv6NullableArrayArray(ctx context.Context, request string) ([][]NilIPv6, error) + // TestResponseStringMAC invokes test_response_string_mac operation. + // + // POST /test_response_string_mac + TestResponseStringMAC(ctx context.Context, request string) (net.HardwareAddr, error) + // TestResponseStringMACArray invokes test_response_string_mac_array operation. + // + // POST /test_response_string_mac_array + TestResponseStringMACArray(ctx context.Context, request string) ([]net.HardwareAddr, error) + // TestResponseStringMACArrayArray invokes test_response_string_mac_array_array operation. + // + // POST /test_response_string_mac_array_array + TestResponseStringMACArrayArray(ctx context.Context, request string) ([][]net.HardwareAddr, error) + // TestResponseStringMACNullable invokes test_response_string_mac_nullable operation. + // + // POST /test_response_string_mac_nullable + TestResponseStringMACNullable(ctx context.Context, request string) (NilHardwareAddr, error) + // TestResponseStringMACNullableArray invokes test_response_string_mac_nullable_array operation. + // + // POST /test_response_string_mac_nullable_array + TestResponseStringMACNullableArray(ctx context.Context, request string) ([]NilHardwareAddr, error) + // TestResponseStringMACNullableArrayArray invokes test_response_string_mac_nullable_array_array operation. + // + // POST /test_response_string_mac_nullable_array_array + TestResponseStringMACNullableArrayArray(ctx context.Context, request string) ([][]NilHardwareAddr, error) // TestResponseStringNullable invokes test_response_string_nullable operation. // // POST /test_response_string_nullable @@ -5606,6 +5679,43 @@ func (c *Client) sendTestQueryParameter(ctx context.Context, request string, par return res, errors.Wrap(err, "encode query") } } + { + // Encode "string_mac" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "string_mac", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeValue(conv.HardwareAddrToString(params.StringMAC)) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "string_mac_array" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "string_mac_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.StringMACArray { + if err := func() error { + return e.EncodeValue(conv.HardwareAddrToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } { // Encode "string_password" parameter. cfg := uri.QueryParameterEncodingConfig{ @@ -33964,6 +34074,444 @@ func (c *Client) sendTestRequestRequiredStringIpv6NullableArrayArray(ctx context return result, nil } +// TestRequestRequiredStringMAC invokes test_request_required_string_mac operation. +// +// POST /test_request_required_string_mac +func (c *Client) TestRequestRequiredStringMAC(ctx context.Context, request net.HardwareAddr) (*Error, error) { + res, err := c.sendTestRequestRequiredStringMAC(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestRequiredStringMAC(ctx context.Context, request net.HardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_string_mac"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringMAC", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_required_string_mac" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredStringMACRequest(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 := decodeTestRequestRequiredStringMACResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredStringMACArray invokes test_request_required_string_mac_array operation. +// +// POST /test_request_required_string_mac_array +func (c *Client) TestRequestRequiredStringMACArray(ctx context.Context, request []net.HardwareAddr) (*Error, error) { + res, err := c.sendTestRequestRequiredStringMACArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestRequiredStringMACArray(ctx context.Context, request []net.HardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_string_mac_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringMACArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_required_string_mac_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredStringMACArrayRequest(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 := decodeTestRequestRequiredStringMACArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredStringMACArrayArray invokes test_request_required_string_mac_array_array operation. +// +// POST /test_request_required_string_mac_array_array +func (c *Client) TestRequestRequiredStringMACArrayArray(ctx context.Context, request [][]net.HardwareAddr) (*Error, error) { + res, err := c.sendTestRequestRequiredStringMACArrayArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestRequiredStringMACArrayArray(ctx context.Context, request [][]net.HardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_string_mac_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_array_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringMACArrayArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_required_string_mac_array_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredStringMACArrayArrayRequest(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 := decodeTestRequestRequiredStringMACArrayArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredStringMACNullable invokes test_request_required_string_mac_nullable operation. +// +// POST /test_request_required_string_mac_nullable +func (c *Client) TestRequestRequiredStringMACNullable(ctx context.Context, request NilHardwareAddr) (*Error, error) { + res, err := c.sendTestRequestRequiredStringMACNullable(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestRequiredStringMACNullable(ctx context.Context, request NilHardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_string_mac_nullable"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_nullable"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringMACNullable", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_required_string_mac_nullable" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredStringMACNullableRequest(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 := decodeTestRequestRequiredStringMACNullableResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredStringMACNullableArray invokes test_request_required_string_mac_nullable_array operation. +// +// POST /test_request_required_string_mac_nullable_array +func (c *Client) TestRequestRequiredStringMACNullableArray(ctx context.Context, request []NilHardwareAddr) (*Error, error) { + res, err := c.sendTestRequestRequiredStringMACNullableArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestRequiredStringMACNullableArray(ctx context.Context, request []NilHardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_string_mac_nullable_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_nullable_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringMACNullableArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_required_string_mac_nullable_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredStringMACNullableArrayRequest(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 := decodeTestRequestRequiredStringMACNullableArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestRequiredStringMACNullableArrayArray invokes test_request_required_string_mac_nullable_array_array operation. +// +// POST /test_request_required_string_mac_nullable_array_array +func (c *Client) TestRequestRequiredStringMACNullableArrayArray(ctx context.Context, request [][]NilHardwareAddr) (*Error, error) { + res, err := c.sendTestRequestRequiredStringMACNullableArrayArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestRequiredStringMACNullableArrayArray(ctx context.Context, request [][]NilHardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_required_string_mac_nullable_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_nullable_array_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestRequiredStringMACNullableArrayArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_required_string_mac_nullable_array_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestRequiredStringMACNullableArrayArrayRequest(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 := decodeTestRequestRequiredStringMACNullableArrayArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // TestRequestRequiredStringNullable invokes test_request_required_string_nullable operation. // // POST /test_request_required_string_nullable @@ -48418,6 +48966,444 @@ func (c *Client) sendTestRequestStringIpv6NullableArrayArray(ctx context.Context return result, nil } +// TestRequestStringMAC invokes test_request_string_mac operation. +// +// POST /test_request_string_mac +func (c *Client) TestRequestStringMAC(ctx context.Context, request OptHardwareAddr) (*Error, error) { + res, err := c.sendTestRequestStringMAC(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestStringMAC(ctx context.Context, request OptHardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_mac"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_string_mac"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringMAC", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_string_mac" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringMACRequest(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 := decodeTestRequestStringMACResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringMACArray invokes test_request_string_mac_array operation. +// +// POST /test_request_string_mac_array +func (c *Client) TestRequestStringMACArray(ctx context.Context, request []net.HardwareAddr) (*Error, error) { + res, err := c.sendTestRequestStringMACArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestStringMACArray(ctx context.Context, request []net.HardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_mac_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_string_mac_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringMACArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_string_mac_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringMACArrayRequest(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 := decodeTestRequestStringMACArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringMACArrayArray invokes test_request_string_mac_array_array operation. +// +// POST /test_request_string_mac_array_array +func (c *Client) TestRequestStringMACArrayArray(ctx context.Context, request [][]net.HardwareAddr) (*Error, error) { + res, err := c.sendTestRequestStringMACArrayArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestStringMACArrayArray(ctx context.Context, request [][]net.HardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_mac_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_string_mac_array_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringMACArrayArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_string_mac_array_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringMACArrayArrayRequest(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 := decodeTestRequestStringMACArrayArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringMACNullable invokes test_request_string_mac_nullable operation. +// +// POST /test_request_string_mac_nullable +func (c *Client) TestRequestStringMACNullable(ctx context.Context, request OptNilHardwareAddr) (*Error, error) { + res, err := c.sendTestRequestStringMACNullable(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestStringMACNullable(ctx context.Context, request OptNilHardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_mac_nullable"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_string_mac_nullable"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringMACNullable", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_string_mac_nullable" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringMACNullableRequest(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 := decodeTestRequestStringMACNullableResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringMACNullableArray invokes test_request_string_mac_nullable_array operation. +// +// POST /test_request_string_mac_nullable_array +func (c *Client) TestRequestStringMACNullableArray(ctx context.Context, request []NilHardwareAddr) (*Error, error) { + res, err := c.sendTestRequestStringMACNullableArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestStringMACNullableArray(ctx context.Context, request []NilHardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_mac_nullable_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_string_mac_nullable_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringMACNullableArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_string_mac_nullable_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringMACNullableArrayRequest(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 := decodeTestRequestStringMACNullableArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestRequestStringMACNullableArrayArray invokes test_request_string_mac_nullable_array_array operation. +// +// POST /test_request_string_mac_nullable_array_array +func (c *Client) TestRequestStringMACNullableArrayArray(ctx context.Context, request [][]NilHardwareAddr) (*Error, error) { + res, err := c.sendTestRequestStringMACNullableArrayArray(ctx, request) + return res, err +} + +func (c *Client) sendTestRequestStringMACNullableArrayArray(ctx context.Context, request [][]NilHardwareAddr) (res *Error, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_request_string_mac_nullable_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_request_string_mac_nullable_array_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestRequestStringMACNullableArrayArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_request_string_mac_nullable_array_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestRequestStringMACNullableArrayArrayRequest(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 := decodeTestRequestStringMACNullableArrayArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // TestRequestStringNullable invokes test_request_string_nullable operation. // // POST /test_request_string_nullable @@ -72727,6 +73713,444 @@ func (c *Client) sendTestResponseStringIpv6NullableArrayArray(ctx context.Contex return result, nil } +// TestResponseStringMAC invokes test_response_string_mac operation. +// +// POST /test_response_string_mac +func (c *Client) TestResponseStringMAC(ctx context.Context, request string) (net.HardwareAddr, error) { + res, err := c.sendTestResponseStringMAC(ctx, request) + return res, err +} + +func (c *Client) sendTestResponseStringMAC(ctx context.Context, request string) (res net.HardwareAddr, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_mac"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_mac"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseStringMAC", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_response_string_mac" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestResponseStringMACRequest(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 := decodeTestResponseStringMACResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestResponseStringMACArray invokes test_response_string_mac_array operation. +// +// POST /test_response_string_mac_array +func (c *Client) TestResponseStringMACArray(ctx context.Context, request string) ([]net.HardwareAddr, error) { + res, err := c.sendTestResponseStringMACArray(ctx, request) + return res, err +} + +func (c *Client) sendTestResponseStringMACArray(ctx context.Context, request string) (res []net.HardwareAddr, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_mac_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_mac_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseStringMACArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_response_string_mac_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestResponseStringMACArrayRequest(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 := decodeTestResponseStringMACArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestResponseStringMACArrayArray invokes test_response_string_mac_array_array operation. +// +// POST /test_response_string_mac_array_array +func (c *Client) TestResponseStringMACArrayArray(ctx context.Context, request string) ([][]net.HardwareAddr, error) { + res, err := c.sendTestResponseStringMACArrayArray(ctx, request) + return res, err +} + +func (c *Client) sendTestResponseStringMACArrayArray(ctx context.Context, request string) (res [][]net.HardwareAddr, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_mac_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_mac_array_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseStringMACArrayArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_response_string_mac_array_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestResponseStringMACArrayArrayRequest(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 := decodeTestResponseStringMACArrayArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestResponseStringMACNullable invokes test_response_string_mac_nullable operation. +// +// POST /test_response_string_mac_nullable +func (c *Client) TestResponseStringMACNullable(ctx context.Context, request string) (NilHardwareAddr, error) { + res, err := c.sendTestResponseStringMACNullable(ctx, request) + return res, err +} + +func (c *Client) sendTestResponseStringMACNullable(ctx context.Context, request string) (res NilHardwareAddr, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_mac_nullable"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_mac_nullable"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseStringMACNullable", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_response_string_mac_nullable" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestResponseStringMACNullableRequest(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 := decodeTestResponseStringMACNullableResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestResponseStringMACNullableArray invokes test_response_string_mac_nullable_array operation. +// +// POST /test_response_string_mac_nullable_array +func (c *Client) TestResponseStringMACNullableArray(ctx context.Context, request string) ([]NilHardwareAddr, error) { + res, err := c.sendTestResponseStringMACNullableArray(ctx, request) + return res, err +} + +func (c *Client) sendTestResponseStringMACNullableArray(ctx context.Context, request string) (res []NilHardwareAddr, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_mac_nullable_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_mac_nullable_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseStringMACNullableArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_response_string_mac_nullable_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestResponseStringMACNullableArrayRequest(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 := decodeTestResponseStringMACNullableArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// TestResponseStringMACNullableArrayArray invokes test_response_string_mac_nullable_array_array operation. +// +// POST /test_response_string_mac_nullable_array_array +func (c *Client) TestResponseStringMACNullableArrayArray(ctx context.Context, request string) ([][]NilHardwareAddr, error) { + res, err := c.sendTestResponseStringMACNullableArrayArray(ctx, request) + return res, err +} + +func (c *Client) sendTestResponseStringMACNullableArrayArray(ctx context.Context, request string) (res [][]NilHardwareAddr, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_mac_nullable_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_mac_nullable_array_array"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, "TestResponseStringMACNullableArrayArray", + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // 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, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [1]string + pathParts[0] = "/test_response_string_mac_nullable_array_array" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + if err := encodeTestResponseStringMACNullableArrayArrayRequest(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 := decodeTestResponseStringMACNullableArrayArrayResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // TestResponseStringNullable invokes test_response_string_nullable operation. // // POST /test_response_string_nullable diff --git a/examples/ex_test_format/oas_faker_gen.go b/examples/ex_test_format/oas_faker_gen.go index ad5c96d44..ed1b373fb 100644 --- a/examples/ex_test_format/oas_faker_gen.go +++ b/examples/ex_test_format/oas_faker_gen.go @@ -3,6 +3,7 @@ package api import ( + "net" "net/netip" "net/url" "time" @@ -55,6 +56,11 @@ func (s *NilFloat64) SetFake() { s.Null = true } +// SetFake set fake values. +func (s *NilHardwareAddr) SetFake() { + s.Null = true +} + // SetFake set fake values. func (s *NilIP) SetFake() { s.Null = true @@ -294,6 +300,15 @@ func (s *OptFloat64) SetFake() { s.SetTo(elem) } +// SetFake set fake values. +func (s *OptHardwareAddr) SetFake() { + var elem net.HardwareAddr + { + elem = net.ParseMAC("11:22:33:44:55:66") + } + s.SetTo(elem) +} + // SetFake set fake values. func (s *OptIP) SetFake() { var elem netip.Addr @@ -408,6 +423,12 @@ func (s *OptNilFloat64) SetFake() { s.Set = true } +// SetFake set fake values. +func (s *OptNilHardwareAddr) SetFake() { + s.Null = true + s.Set = true +} + // SetFake set fake values. func (s *OptNilIP) SetFake() { s.Null = true @@ -1424,6 +1445,18 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.RequiredArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem net.HardwareAddr + { + elem = net.ParseMAC("11:22:33:44:55:66") + } + s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) + } + } + } { { s.RequiredArrayStringPassword = nil @@ -2395,6 +2428,25 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.RequiredDoubleArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem []net.HardwareAddr + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem net.HardwareAddr + { + elemElem = net.ParseMAC("11:22:33:44:55:66") + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayStringMAC = append(s.RequiredDoubleArrayStringMAC, elem) + } + } + } { { s.RequiredDoubleArrayStringPassword = nil @@ -2861,6 +2913,11 @@ func (s *TestRequestFormatTestReq) SetFake() { s.RequiredStringIpv6 = netip.MustParseAddr("::1") } } + { + { + s.RequiredStringMAC = net.ParseMAC("11:22:33:44:55:66") + } + } { { s.RequiredStringPassword = "string" @@ -3440,6 +3497,18 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.OptionalArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem net.HardwareAddr + { + elem = net.ParseMAC("11:22:33:44:55:66") + } + s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) + } + } + } { { s.OptionalArrayStringPassword = nil @@ -4411,6 +4480,25 @@ func (s *TestRequestFormatTestReq) SetFake() { } } } + { + { + s.OptionalDoubleArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem []net.HardwareAddr + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem net.HardwareAddr + { + elemElem = net.ParseMAC("11:22:33:44:55:66") + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayStringMAC = append(s.OptionalDoubleArrayStringMAC, elem) + } + } + } { { s.OptionalDoubleArrayStringPassword = nil @@ -4877,6 +4965,11 @@ func (s *TestRequestFormatTestReq) SetFake() { s.OptionalStringIpv6.SetFake() } } + { + { + s.OptionalStringMAC.SetFake() + } + } { { s.OptionalStringPassword.SetFake() @@ -5464,6 +5557,18 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } } } + { + { + s.RequiredArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem net.HardwareAddr + { + elem = net.ParseMAC("11:22:33:44:55:66") + } + s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) + } + } + } { { s.RequiredArrayStringPassword = nil @@ -6435,6 +6540,25 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } } } + { + { + s.RequiredDoubleArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem []net.HardwareAddr + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem net.HardwareAddr + { + elemElem = net.ParseMAC("11:22:33:44:55:66") + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayStringMAC = append(s.RequiredDoubleArrayStringMAC, elem) + } + } + } { { s.RequiredDoubleArrayStringPassword = nil @@ -6901,6 +7025,11 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { s.RequiredStringIpv6 = netip.MustParseAddr("::1") } } + { + { + s.RequiredStringMAC = net.ParseMAC("11:22:33:44:55:66") + } + } { { s.RequiredStringPassword = "string" @@ -7480,6 +7609,18 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } } } + { + { + s.OptionalArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem net.HardwareAddr + { + elem = net.ParseMAC("11:22:33:44:55:66") + } + s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) + } + } + } { { s.OptionalArrayStringPassword = nil @@ -8451,6 +8592,25 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } } } + { + { + s.OptionalDoubleArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem []net.HardwareAddr + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem net.HardwareAddr + { + elemElem = net.ParseMAC("11:22:33:44:55:66") + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayStringMAC = append(s.OptionalDoubleArrayStringMAC, elem) + } + } + } { { s.OptionalDoubleArrayStringPassword = nil @@ -8917,6 +9077,11 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { s.OptionalStringIpv6.SetFake() } } + { + { + s.OptionalStringMAC.SetFake() + } + } { { s.OptionalStringPassword.SetFake() @@ -9504,6 +9669,18 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.RequiredArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem net.HardwareAddr + { + elem = net.ParseMAC("11:22:33:44:55:66") + } + s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) + } + } + } { { s.RequiredArrayStringPassword = nil @@ -10475,6 +10652,25 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.RequiredDoubleArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem []net.HardwareAddr + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem net.HardwareAddr + { + elemElem = net.ParseMAC("11:22:33:44:55:66") + } + elem = append(elem, elemElem) + } + } + s.RequiredDoubleArrayStringMAC = append(s.RequiredDoubleArrayStringMAC, elem) + } + } + } { { s.RequiredDoubleArrayStringPassword = nil @@ -10941,6 +11137,11 @@ func (s *TestResponseFormatTestOK) SetFake() { s.RequiredStringIpv6 = netip.MustParseAddr("::1") } } + { + { + s.RequiredStringMAC = net.ParseMAC("11:22:33:44:55:66") + } + } { { s.RequiredStringPassword = "string" @@ -11520,6 +11721,18 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.OptionalArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem net.HardwareAddr + { + elem = net.ParseMAC("11:22:33:44:55:66") + } + s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) + } + } + } { { s.OptionalArrayStringPassword = nil @@ -12491,6 +12704,25 @@ func (s *TestResponseFormatTestOK) SetFake() { } } } + { + { + s.OptionalDoubleArrayStringMAC = nil + for i := 0; i < 0; i++ { + var elem []net.HardwareAddr + { + elem = nil + for i := 0; i < 0; i++ { + var elemElem net.HardwareAddr + { + elemElem = net.ParseMAC("11:22:33:44:55:66") + } + elem = append(elem, elemElem) + } + } + s.OptionalDoubleArrayStringMAC = append(s.OptionalDoubleArrayStringMAC, elem) + } + } + } { { s.OptionalDoubleArrayStringPassword = nil @@ -12957,6 +13189,11 @@ func (s *TestResponseFormatTestOK) SetFake() { s.OptionalStringIpv6.SetFake() } } + { + { + s.OptionalStringMAC.SetFake() + } + } { { s.OptionalStringPassword.SetFake() diff --git a/examples/ex_test_format/oas_handlers_gen.go b/examples/ex_test_format/oas_handlers_gen.go index 5d29949eb..a5e05e6fa 100644 --- a/examples/ex_test_format/oas_handlers_gen.go +++ b/examples/ex_test_format/oas_handlers_gen.go @@ -4,6 +4,7 @@ package api import ( "context" + "net" "net/http" "net/netip" "net/url" @@ -419,6 +420,14 @@ func (s *Server) handleTestQueryParameterRequest(args [0]string, argsEscaped boo Name: "string_ipv6_array", In: "query", }: params.StringIpv6Array, + { + Name: "string_mac", + In: "query", + }: params.StringMAC, + { + Name: "string_mac_array", + In: "query", + }: params.StringMACArray, { Name: "string_password", In: "query", @@ -40195,18 +40204,18 @@ func (s *Server) handleTestRequestRequiredStringIpv6NullableArrayArrayRequest(ar } } -// handleTestRequestRequiredStringNullableRequest handles test_request_required_string_nullable operation. +// handleTestRequestRequiredStringMACRequest handles test_request_required_string_mac operation. // -// POST /test_request_required_string_nullable -func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_mac +func (s *Server) handleTestRequestRequiredStringMACRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable"), + otelogen.OperationID("test_request_required_string_mac"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringMAC", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40231,11 +40240,11 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringNullable", - ID: "test_request_required_string_nullable", + Name: "TestRequestRequiredStringMAC", + ID: "test_request_required_string_mac", } ) - request, close, err := s.decodeTestRequestRequiredStringNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringMACRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40255,16 +40264,16 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringNullable", + OperationName: "TestRequestRequiredStringMAC", OperationSummary: "", - OperationID: "test_request_required_string_nullable", + OperationID: "test_request_required_string_mac", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilString + Request = net.HardwareAddr Params = struct{} Response = *Error ) @@ -40277,12 +40286,12 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringMAC(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringMAC(ctx, request) } if err != nil { recordError("Internal", err) @@ -40290,7 +40299,7 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringMACResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -40299,18 +40308,18 @@ func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, } } -// handleTestRequestRequiredStringNullableArrayRequest handles test_request_required_string_nullable_array operation. +// handleTestRequestRequiredStringMACArrayRequest handles test_request_required_string_mac_array operation. // -// POST /test_request_required_string_nullable_array -func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_mac_array +func (s *Server) handleTestRequestRequiredStringMACArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable_array"), + otelogen.OperationID("test_request_required_string_mac_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringMACArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40335,11 +40344,11 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringNullableArray", - ID: "test_request_required_string_nullable_array", + Name: "TestRequestRequiredStringMACArray", + ID: "test_request_required_string_mac_array", } ) - request, close, err := s.decodeTestRequestRequiredStringNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringMACArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40359,16 +40368,16 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringNullableArray", + OperationName: "TestRequestRequiredStringMACArray", OperationSummary: "", - OperationID: "test_request_required_string_nullable_array", + OperationID: "test_request_required_string_mac_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilString + Request = []net.HardwareAddr Params = struct{} Response = *Error ) @@ -40381,12 +40390,12 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40394,7 +40403,7 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringMACArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -40403,18 +40412,18 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]str } } -// handleTestRequestRequiredStringNullableArrayArrayRequest handles test_request_required_string_nullable_array_array operation. +// handleTestRequestRequiredStringMACArrayArrayRequest handles test_request_required_string_mac_array_array operation. // -// POST /test_request_required_string_nullable_array_array -func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_mac_array_array +func (s *Server) handleTestRequestRequiredStringMACArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_nullable_array_array"), + otelogen.OperationID("test_request_required_string_mac_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_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(), "TestRequestRequiredStringMACArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40439,11 +40448,11 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringNullableArrayArray", - ID: "test_request_required_string_nullable_array_array", + Name: "TestRequestRequiredStringMACArrayArray", + ID: "test_request_required_string_mac_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringMACArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40463,16 +40472,16 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringNullableArrayArray", + OperationName: "TestRequestRequiredStringMACArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_nullable_array_array", + OperationID: "test_request_required_string_mac_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]net.HardwareAddr Params = struct{} Response = *Error ) @@ -40485,12 +40494,12 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40498,7 +40507,7 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringMACArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -40507,18 +40516,18 @@ func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [ } } -// handleTestRequestRequiredStringPasswordRequest handles test_request_required_string_password operation. +// handleTestRequestRequiredStringMACNullableRequest handles test_request_required_string_mac_nullable operation. // -// POST /test_request_required_string_password -func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_mac_nullable +func (s *Server) handleTestRequestRequiredStringMACNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password"), + otelogen.OperationID("test_request_required_string_mac_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_password"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPassword", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringMACNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40543,11 +40552,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPassword", - ID: "test_request_required_string_password", + Name: "TestRequestRequiredStringMACNullable", + ID: "test_request_required_string_mac_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordRequest(r) + request, close, err := s.decodeTestRequestRequiredStringMACNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40567,16 +40576,16 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPassword", + OperationName: "TestRequestRequiredStringMACNullable", OperationSummary: "", - OperationID: "test_request_required_string_password", + OperationID: "test_request_required_string_mac_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = NilHardwareAddr Params = struct{} Response = *Error ) @@ -40589,12 +40598,12 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringPassword(ctx, request) + response, err = s.h.TestRequestRequiredStringMACNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringPassword(ctx, request) + response, err = s.h.TestRequestRequiredStringMACNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -40602,7 +40611,7 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringPasswordResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringMACNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -40611,18 +40620,18 @@ func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, } } -// handleTestRequestRequiredStringPasswordArrayRequest handles test_request_required_string_password_array operation. +// handleTestRequestRequiredStringMACNullableArrayRequest handles test_request_required_string_mac_nullable_array operation. // -// POST /test_request_required_string_password_array -func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_mac_nullable_array +func (s *Server) handleTestRequestRequiredStringMACNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_array"), + otelogen.OperationID("test_request_required_string_mac_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_password_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringMACNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40647,11 +40656,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordArray", - ID: "test_request_required_string_password_array", + Name: "TestRequestRequiredStringMACNullableArray", + ID: "test_request_required_string_mac_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringMACNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40671,16 +40680,16 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordArray", + OperationName: "TestRequestRequiredStringMACNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_password_array", + OperationID: "test_request_required_string_mac_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []string + Request = []NilHardwareAddr Params = struct{} Response = *Error ) @@ -40693,12 +40702,12 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringPasswordArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40706,7 +40715,7 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringPasswordArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringMACNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -40715,18 +40724,18 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]str } } -// handleTestRequestRequiredStringPasswordArrayArrayRequest handles test_request_required_string_password_array_array operation. +// handleTestRequestRequiredStringMACNullableArrayArrayRequest handles test_request_required_string_mac_nullable_array_array operation. // -// POST /test_request_required_string_password_array_array -func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_mac_nullable_array_array +func (s *Server) handleTestRequestRequiredStringMACNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_array_array"), + otelogen.OperationID("test_request_required_string_mac_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_password_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_mac_nullable_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(), "TestRequestRequiredStringMACNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40751,11 +40760,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordArrayArray", - ID: "test_request_required_string_password_array_array", + Name: "TestRequestRequiredStringMACNullableArrayArray", + ID: "test_request_required_string_mac_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringMACNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40775,16 +40784,16 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordArrayArray", + OperationName: "TestRequestRequiredStringMACNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_password_array_array", + OperationID: "test_request_required_string_mac_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]string + Request = [][]NilHardwareAddr Params = struct{} Response = *Error ) @@ -40797,12 +40806,12 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringMACNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -40810,7 +40819,7 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringPasswordArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringMACNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -40819,18 +40828,18 @@ func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [ } } -// handleTestRequestRequiredStringPasswordNullableRequest handles test_request_required_string_password_nullable operation. +// handleTestRequestRequiredStringNullableRequest handles test_request_required_string_nullable operation. // -// POST /test_request_required_string_password_nullable -func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_nullable +func (s *Server) handleTestRequestRequiredStringNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable"), + otelogen.OperationID("test_request_required_string_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_password_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40855,11 +40864,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordNullable", - ID: "test_request_required_string_password_nullable", + Name: "TestRequestRequiredStringNullable", + ID: "test_request_required_string_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40879,9 +40888,9 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordNullable", + OperationName: "TestRequestRequiredStringNullable", OperationSummary: "", - OperationID: "test_request_required_string_password_nullable", + OperationID: "test_request_required_string_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -40901,12 +40910,12 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringPasswordNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -40914,7 +40923,7 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] return } - if err := encodeTestRequestRequiredStringPasswordNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -40923,18 +40932,18 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0] } } -// handleTestRequestRequiredStringPasswordNullableArrayRequest handles test_request_required_string_password_nullable_array operation. +// handleTestRequestRequiredStringNullableArrayRequest handles test_request_required_string_nullable_array operation. // -// POST /test_request_required_string_password_nullable_array -func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_nullable_array +func (s *Server) handleTestRequestRequiredStringNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_password_nullable_array"), + otelogen.OperationID("test_request_required_string_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_password_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_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(), "TestRequestRequiredStringNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -40959,11 +40968,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordNullableArray", - ID: "test_request_required_string_password_nullable_array", + Name: "TestRequestRequiredStringNullableArray", + ID: "test_request_required_string_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -40983,9 +40992,9 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordNullableArray", + OperationName: "TestRequestRequiredStringNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_password_nullable_array", + OperationID: "test_request_required_string_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -41005,12 +41014,12 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41018,7 +41027,7 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg return } - if err := encodeTestRequestRequiredStringPasswordNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41027,18 +41036,18 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(arg } } -// handleTestRequestRequiredStringPasswordNullableArrayArrayRequest handles test_request_required_string_password_nullable_array_array operation. +// handleTestRequestRequiredStringNullableArrayArrayRequest handles test_request_required_string_nullable_array_array operation. // -// POST /test_request_required_string_password_nullable_array_array -func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_nullable_array_array +func (s *Server) handleTestRequestRequiredStringNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_password_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_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(), "TestRequestRequiredStringNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41063,11 +41072,11 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringPasswordNullableArrayArray", - ID: "test_request_required_string_password_nullable_array_array", + Name: "TestRequestRequiredStringNullableArrayArray", + ID: "test_request_required_string_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41087,9 +41096,9 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringPasswordNullableArrayArray", + OperationName: "TestRequestRequiredStringNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_password_nullable_array_array", + OperationID: "test_request_required_string_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -41109,12 +41118,12 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41122,7 +41131,7 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques return } - if err := encodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41131,18 +41140,18 @@ func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayReques } } -// handleTestRequestRequiredStringTimeRequest handles test_request_required_string_time operation. +// handleTestRequestRequiredStringPasswordRequest handles test_request_required_string_password operation. // -// POST /test_request_required_string_time -func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password +func (s *Server) handleTestRequestRequiredStringPasswordRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time"), + otelogen.OperationID("test_request_required_string_password"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_time"), + semconv.HTTPRouteKey.String("/test_request_required_string_password"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPassword", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41167,11 +41176,11 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTime", - ID: "test_request_required_string_time", + Name: "TestRequestRequiredStringPassword", + ID: "test_request_required_string_password", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeRequest(r) + request, close, err := s.decodeTestRequestRequiredStringPasswordRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41191,16 +41200,16 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTime", + OperationName: "TestRequestRequiredStringPassword", OperationSummary: "", - OperationID: "test_request_required_string_time", + OperationID: "test_request_required_string_password", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = time.Time + Request = string Params = struct{} Response = *Error ) @@ -41213,12 +41222,12 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringTime(ctx, request) + response, err = s.h.TestRequestRequiredStringPassword(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringTime(ctx, request) + response, err = s.h.TestRequestRequiredStringPassword(ctx, request) } if err != nil { recordError("Internal", err) @@ -41226,7 +41235,7 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, args return } - if err := encodeTestRequestRequiredStringTimeResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41235,18 +41244,18 @@ func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, args } } -// handleTestRequestRequiredStringTimeArrayRequest handles test_request_required_string_time_array operation. +// handleTestRequestRequiredStringPasswordArrayRequest handles test_request_required_string_password_array operation. // -// POST /test_request_required_string_time_array -func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_array +func (s *Server) handleTestRequestRequiredStringPasswordArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_array"), + otelogen.OperationID("test_request_required_string_password_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_time_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_password_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41271,11 +41280,11 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeArray", - ID: "test_request_required_string_time_array", + Name: "TestRequestRequiredStringPasswordArray", + ID: "test_request_required_string_password_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringPasswordArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41295,16 +41304,16 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeArray", + OperationName: "TestRequestRequiredStringPasswordArray", OperationSummary: "", - OperationID: "test_request_required_string_time_array", + OperationID: "test_request_required_string_password_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = []string Params = struct{} Response = *Error ) @@ -41317,12 +41326,12 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringTimeArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41330,7 +41339,7 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41339,18 +41348,18 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, } } -// handleTestRequestRequiredStringTimeArrayArrayRequest handles test_request_required_string_time_array_array operation. +// handleTestRequestRequiredStringPasswordArrayArrayRequest handles test_request_required_string_password_array_array operation. // -// POST /test_request_required_string_time_array_array -func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_array_array +func (s *Server) handleTestRequestRequiredStringPasswordArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_array_array"), + otelogen.OperationID("test_request_required_string_password_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_time_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_password_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(), "TestRequestRequiredStringPasswordArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41375,11 +41384,11 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeArrayArray", - ID: "test_request_required_string_time_array_array", + Name: "TestRequestRequiredStringPasswordArrayArray", + ID: "test_request_required_string_password_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringPasswordArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41399,16 +41408,16 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeArrayArray", + OperationName: "TestRequestRequiredStringPasswordArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_time_array_array", + OperationID: "test_request_required_string_password_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]string Params = struct{} Response = *Error ) @@ -41421,12 +41430,12 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41434,7 +41443,7 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41443,18 +41452,18 @@ func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]st } } -// handleTestRequestRequiredStringTimeNullableRequest handles test_request_required_string_time_nullable operation. +// handleTestRequestRequiredStringPasswordNullableRequest handles test_request_required_string_password_nullable operation. // -// POST /test_request_required_string_time_nullable -func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_nullable +func (s *Server) handleTestRequestRequiredStringPasswordNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable"), + otelogen.OperationID("test_request_required_string_password_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_time_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_password_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringPasswordNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41479,11 +41488,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeNullable", - ID: "test_request_required_string_time_nullable", + Name: "TestRequestRequiredStringPasswordNullable", + ID: "test_request_required_string_password_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringPasswordNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41503,16 +41512,16 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeNullable", + OperationName: "TestRequestRequiredStringPasswordNullable", OperationSummary: "", - OperationID: "test_request_required_string_time_nullable", + OperationID: "test_request_required_string_password_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilTime + Request = NilString Params = struct{} Response = *Error ) @@ -41525,12 +41534,12 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringTimeNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -41538,7 +41547,7 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41547,18 +41556,18 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]stri } } -// handleTestRequestRequiredStringTimeNullableArrayRequest handles test_request_required_string_time_nullable_array operation. +// handleTestRequestRequiredStringPasswordNullableArrayRequest handles test_request_required_string_password_nullable_array operation. // -// POST /test_request_required_string_time_nullable_array -func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_nullable_array +func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_time_nullable_array"), + otelogen.OperationID("test_request_required_string_password_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_time_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_password_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(), "TestRequestRequiredStringPasswordNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41583,11 +41592,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeNullableArray", - ID: "test_request_required_string_time_nullable_array", + Name: "TestRequestRequiredStringPasswordNullableArray", + ID: "test_request_required_string_password_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41607,16 +41616,16 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeNullableArray", + OperationName: "TestRequestRequiredStringPasswordNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_time_nullable_array", + OperationID: "test_request_required_string_password_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilTime + Request = []NilString Params = struct{} Response = *Error ) @@ -41629,12 +41638,12 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41642,7 +41651,7 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41651,18 +41660,18 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0 } } -// handleTestRequestRequiredStringTimeNullableArrayArrayRequest handles test_request_required_string_time_nullable_array_array operation. +// handleTestRequestRequiredStringPasswordNullableArrayArrayRequest handles test_request_required_string_password_nullable_array_array operation. // -// POST /test_request_required_string_time_nullable_array_array -func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_password_nullable_array_array +func (s *Server) handleTestRequestRequiredStringPasswordNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_password_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_time_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_password_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(), "TestRequestRequiredStringPasswordNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41687,11 +41696,11 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringTimeNullableArrayArray", - ID: "test_request_required_string_time_nullable_array_array", + Name: "TestRequestRequiredStringPasswordNullableArrayArray", + ID: "test_request_required_string_password_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41711,16 +41720,16 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringTimeNullableArrayArray", + OperationName: "TestRequestRequiredStringPasswordNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_time_nullable_array_array", + OperationID: "test_request_required_string_password_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilTime + Request = [][]NilString Params = struct{} Response = *Error ) @@ -41733,12 +41742,12 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringPasswordNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41746,7 +41755,7 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41755,18 +41764,18 @@ func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(ar } } -// handleTestRequestRequiredStringURIRequest handles test_request_required_string_uri operation. +// handleTestRequestRequiredStringTimeRequest handles test_request_required_string_time operation. // -// POST /test_request_required_string_uri -func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time +func (s *Server) handleTestRequestRequiredStringTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri"), + otelogen.OperationID("test_request_required_string_time"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uri"), + semconv.HTTPRouteKey.String("/test_request_required_string_time"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURI", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTime", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41791,11 +41800,11 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURI", - ID: "test_request_required_string_uri", + Name: "TestRequestRequiredStringTime", + ID: "test_request_required_string_time", } ) - request, close, err := s.decodeTestRequestRequiredStringURIRequest(r) + request, close, err := s.decodeTestRequestRequiredStringTimeRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41815,16 +41824,16 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURI", + OperationName: "TestRequestRequiredStringTime", OperationSummary: "", - OperationID: "test_request_required_string_uri", + OperationID: "test_request_required_string_time", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = url.URL + Request = time.Time Params = struct{} Response = *Error ) @@ -41837,12 +41846,12 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringURI(ctx, request) + response, err = s.h.TestRequestRequiredStringTime(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringURI(ctx, request) + response, err = s.h.TestRequestRequiredStringTime(ctx, request) } if err != nil { recordError("Internal", err) @@ -41850,7 +41859,7 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, argsE return } - if err := encodeTestRequestRequiredStringURIResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41859,18 +41868,18 @@ func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, argsE } } -// handleTestRequestRequiredStringURIArrayRequest handles test_request_required_string_uri_array operation. +// handleTestRequestRequiredStringTimeArrayRequest handles test_request_required_string_time_array operation. // -// POST /test_request_required_string_uri_array -func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_array +func (s *Server) handleTestRequestRequiredStringTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_array"), + otelogen.OperationID("test_request_required_string_time_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uri_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_time_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURIArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41895,11 +41904,11 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURIArray", - ID: "test_request_required_string_uri_array", + Name: "TestRequestRequiredStringTimeArray", + ID: "test_request_required_string_time_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURIArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringTimeArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -41919,16 +41928,16 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURIArray", + OperationName: "TestRequestRequiredStringTimeArray", OperationSummary: "", - OperationID: "test_request_required_string_uri_array", + OperationID: "test_request_required_string_time_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []url.URL + Request = []time.Time Params = struct{} Response = *Error ) @@ -41941,12 +41950,12 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringURIArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringURIArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -41954,7 +41963,7 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringURIArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -41963,18 +41972,18 @@ func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, } } -// handleTestRequestRequiredStringURIArrayArrayRequest handles test_request_required_string_uri_array_array operation. +// handleTestRequestRequiredStringTimeArrayArrayRequest handles test_request_required_string_time_array_array operation. // -// POST /test_request_required_string_uri_array_array -func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_array_array +func (s *Server) handleTestRequestRequiredStringTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_array_array"), + otelogen.OperationID("test_request_required_string_time_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uri_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_time_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(), "TestRequestRequiredStringTimeArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -41999,11 +42008,11 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURIArrayArray", - ID: "test_request_required_string_uri_array_array", + Name: "TestRequestRequiredStringTimeArrayArray", + ID: "test_request_required_string_time_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURIArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringTimeArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42023,16 +42032,16 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURIArrayArray", + OperationName: "TestRequestRequiredStringTimeArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uri_array_array", + OperationID: "test_request_required_string_time_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]url.URL + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -42045,12 +42054,12 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringURIArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringURIArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42058,7 +42067,7 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringURIArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42067,18 +42076,18 @@ func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]str } } -// handleTestRequestRequiredStringURINullableRequest handles test_request_required_string_uri_nullable operation. +// handleTestRequestRequiredStringTimeNullableRequest handles test_request_required_string_time_nullable operation. // -// POST /test_request_required_string_uri_nullable -func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_nullable +func (s *Server) handleTestRequestRequiredStringTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable"), + otelogen.OperationID("test_request_required_string_time_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uri_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringTimeNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42103,11 +42112,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURINullable", - ID: "test_request_required_string_uri_nullable", + Name: "TestRequestRequiredStringTimeNullable", + ID: "test_request_required_string_time_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringURINullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringTimeNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42127,16 +42136,16 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURINullable", + OperationName: "TestRequestRequiredStringTimeNullable", OperationSummary: "", - OperationID: "test_request_required_string_uri_nullable", + OperationID: "test_request_required_string_time_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilURI + Request = NilTime Params = struct{} Response = *Error ) @@ -42149,12 +42158,12 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringURINullable(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringURINullable(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -42162,7 +42171,7 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringURINullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42171,18 +42180,18 @@ func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]strin } } -// handleTestRequestRequiredStringURINullableArrayRequest handles test_request_required_string_uri_nullable_array operation. +// handleTestRequestRequiredStringTimeNullableArrayRequest handles test_request_required_string_time_nullable_array operation. // -// POST /test_request_required_string_uri_nullable_array -func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_nullable_array +func (s *Server) handleTestRequestRequiredStringTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uri_nullable_array"), + otelogen.OperationID("test_request_required_string_time_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uri_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_time_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(), "TestRequestRequiredStringTimeNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42207,11 +42216,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURINullableArray", - ID: "test_request_required_string_uri_nullable_array", + Name: "TestRequestRequiredStringTimeNullableArray", + ID: "test_request_required_string_time_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURINullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42231,16 +42240,16 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURINullableArray", + OperationName: "TestRequestRequiredStringTimeNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_uri_nullable_array", + OperationID: "test_request_required_string_time_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilURI + Request = []NilTime Params = struct{} Response = *Error ) @@ -42253,12 +42262,12 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringURINullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringURINullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42266,7 +42275,7 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringURINullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42275,18 +42284,18 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0] } } -// handleTestRequestRequiredStringURINullableArrayArrayRequest handles test_request_required_string_uri_nullable_array_array operation. +// handleTestRequestRequiredStringTimeNullableArrayArrayRequest handles test_request_required_string_time_nullable_array_array operation. // -// POST /test_request_required_string_uri_nullable_array_array -func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_time_nullable_array_array +func (s *Server) handleTestRequestRequiredStringTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_time_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uri_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_time_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(), "TestRequestRequiredStringTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42311,11 +42320,11 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringURINullableArrayArray", - ID: "test_request_required_string_uri_nullable_array_array", + Name: "TestRequestRequiredStringTimeNullableArrayArray", + ID: "test_request_required_string_time_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringURINullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42335,16 +42344,16 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringURINullableArrayArray", + OperationName: "TestRequestRequiredStringTimeNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uri_nullable_array_array", + OperationID: "test_request_required_string_time_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilURI + Request = [][]NilTime Params = struct{} Response = *Error ) @@ -42357,12 +42366,12 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42370,7 +42379,7 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg return } - if err := encodeTestRequestRequiredStringURINullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42379,18 +42388,18 @@ func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(arg } } -// handleTestRequestRequiredStringUUIDRequest handles test_request_required_string_uuid operation. +// handleTestRequestRequiredStringURIRequest handles test_request_required_string_uri operation. // -// POST /test_request_required_string_uuid -func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri +func (s *Server) handleTestRequestRequiredStringURIRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid"), + otelogen.OperationID("test_request_required_string_uri"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uuid"), + semconv.HTTPRouteKey.String("/test_request_required_string_uri"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUID", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURI", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42415,11 +42424,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUID", - ID: "test_request_required_string_uuid", + Name: "TestRequestRequiredStringURI", + ID: "test_request_required_string_uri", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDRequest(r) + request, close, err := s.decodeTestRequestRequiredStringURIRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42439,16 +42448,16 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUID", + OperationName: "TestRequestRequiredStringURI", OperationSummary: "", - OperationID: "test_request_required_string_uuid", + OperationID: "test_request_required_string_uri", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = uuid.UUID + Request = url.URL Params = struct{} Response = *Error ) @@ -42461,12 +42470,12 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUUID(ctx, request) + response, err = s.h.TestRequestRequiredStringURI(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUUID(ctx, request) + response, err = s.h.TestRequestRequiredStringURI(ctx, request) } if err != nil { recordError("Internal", err) @@ -42474,7 +42483,7 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, args return } - if err := encodeTestRequestRequiredStringUUIDResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURIResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42483,18 +42492,18 @@ func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, args } } -// handleTestRequestRequiredStringUUIDArrayRequest handles test_request_required_string_uuid_array operation. +// handleTestRequestRequiredStringURIArrayRequest handles test_request_required_string_uri_array operation. // -// POST /test_request_required_string_uuid_array -func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_array +func (s *Server) handleTestRequestRequiredStringURIArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_array"), + otelogen.OperationID("test_request_required_string_uri_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uuid_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uri_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURIArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42519,11 +42528,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDArray", - ID: "test_request_required_string_uuid_array", + Name: "TestRequestRequiredStringURIArray", + ID: "test_request_required_string_uri_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringURIArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42543,16 +42552,16 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDArray", + OperationName: "TestRequestRequiredStringURIArray", OperationSummary: "", - OperationID: "test_request_required_string_uuid_array", + OperationID: "test_request_required_string_uri_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uuid.UUID + Request = []url.URL Params = struct{} Response = *Error ) @@ -42565,12 +42574,12 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUUIDArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURIArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURIArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42578,7 +42587,7 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUUIDArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURIArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42587,18 +42596,18 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, } } -// handleTestRequestRequiredStringUUIDArrayArrayRequest handles test_request_required_string_uuid_array_array operation. +// handleTestRequestRequiredStringURIArrayArrayRequest handles test_request_required_string_uri_array_array operation. // -// POST /test_request_required_string_uuid_array_array -func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_array_array +func (s *Server) handleTestRequestRequiredStringURIArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_array_array"), + otelogen.OperationID("test_request_required_string_uri_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uuid_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uri_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(), "TestRequestRequiredStringURIArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42623,11 +42632,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDArrayArray", - ID: "test_request_required_string_uuid_array_array", + Name: "TestRequestRequiredStringURIArrayArray", + ID: "test_request_required_string_uri_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringURIArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42647,16 +42656,16 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDArrayArray", + OperationName: "TestRequestRequiredStringURIArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uuid_array_array", + OperationID: "test_request_required_string_uri_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uuid.UUID + Request = [][]url.URL Params = struct{} Response = *Error ) @@ -42669,12 +42678,12 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURIArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURIArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42682,7 +42691,7 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUUIDArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURIArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42691,18 +42700,18 @@ func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]st } } -// handleTestRequestRequiredStringUUIDNullableRequest handles test_request_required_string_uuid_nullable operation. +// handleTestRequestRequiredStringURINullableRequest handles test_request_required_string_uri_nullable operation. // -// POST /test_request_required_string_uuid_nullable -func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_nullable +func (s *Server) handleTestRequestRequiredStringURINullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable"), + otelogen.OperationID("test_request_required_string_uri_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uuid_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_uri_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringURINullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42727,11 +42736,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDNullable", - ID: "test_request_required_string_uuid_nullable", + Name: "TestRequestRequiredStringURINullable", + ID: "test_request_required_string_uri_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringURINullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42751,16 +42760,16 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDNullable", + OperationName: "TestRequestRequiredStringURINullable", OperationSummary: "", - OperationID: "test_request_required_string_uuid_nullable", + OperationID: "test_request_required_string_uri_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilUUID + Request = NilURI Params = struct{} Response = *Error ) @@ -42773,12 +42782,12 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUUIDNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -42786,7 +42795,7 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringUUIDNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURINullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42795,18 +42804,18 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]stri } } -// handleTestRequestRequiredStringUUIDNullableArrayRequest handles test_request_required_string_uuid_nullable_array operation. +// handleTestRequestRequiredStringURINullableArrayRequest handles test_request_required_string_uri_nullable_array operation. // -// POST /test_request_required_string_uuid_nullable_array -func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_nullable_array +func (s *Server) handleTestRequestRequiredStringURINullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uuid_nullable_array"), + otelogen.OperationID("test_request_required_string_uri_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uuid_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uri_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(), "TestRequestRequiredStringURINullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42831,11 +42840,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDNullableArray", - ID: "test_request_required_string_uuid_nullable_array", + Name: "TestRequestRequiredStringURINullableArray", + ID: "test_request_required_string_uri_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringURINullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42855,16 +42864,16 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDNullableArray", + OperationName: "TestRequestRequiredStringURINullableArray", OperationSummary: "", - OperationID: "test_request_required_string_uuid_nullable_array", + OperationID: "test_request_required_string_uri_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilUUID + Request = []NilURI Params = struct{} Response = *Error ) @@ -42877,12 +42886,12 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42890,7 +42899,7 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringUUIDNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURINullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -42899,18 +42908,18 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0 } } -// handleTestRequestRequiredStringUUIDNullableArrayArrayRequest handles test_request_required_string_uuid_nullable_array_array operation. +// handleTestRequestRequiredStringURINullableArrayArrayRequest handles test_request_required_string_uri_nullable_array_array operation. // -// POST /test_request_required_string_uuid_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uri_nullable_array_array +func (s *Server) handleTestRequestRequiredStringURINullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_uri_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uuid_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uri_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(), "TestRequestRequiredStringURINullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -42935,11 +42944,11 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUUIDNullableArrayArray", - ID: "test_request_required_string_uuid_nullable_array_array", + Name: "TestRequestRequiredStringURINullableArrayArray", + ID: "test_request_required_string_uri_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringURINullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -42959,16 +42968,16 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUUIDNullableArrayArray", + OperationName: "TestRequestRequiredStringURINullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uuid_nullable_array_array", + OperationID: "test_request_required_string_uri_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilUUID + Request = [][]NilURI Params = struct{} Response = *Error ) @@ -42981,12 +42990,12 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringURINullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -42994,7 +43003,7 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringURINullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43003,18 +43012,18 @@ func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(ar } } -// handleTestRequestRequiredStringUintRequest handles test_request_required_string_uint operation. +// handleTestRequestRequiredStringUUIDRequest handles test_request_required_string_uuid operation. // -// POST /test_request_required_string_uint -func (s *Server) handleTestRequestRequiredStringUintRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid +func (s *Server) handleTestRequestRequiredStringUUIDRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint"), + otelogen.OperationID("test_request_required_string_uuid"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint"), + semconv.HTTPRouteKey.String("/test_request_required_string_uuid"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUID", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43039,11 +43048,11 @@ func (s *Server) handleTestRequestRequiredStringUintRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint", - ID: "test_request_required_string_uint", + Name: "TestRequestRequiredStringUUID", + ID: "test_request_required_string_uuid", } ) - request, close, err := s.decodeTestRequestRequiredStringUintRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUUIDRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43063,16 +43072,16 @@ func (s *Server) handleTestRequestRequiredStringUintRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint", + OperationName: "TestRequestRequiredStringUUID", OperationSummary: "", - OperationID: "test_request_required_string_uint", + OperationID: "test_request_required_string_uuid", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = uint + Request = uuid.UUID Params = struct{} Response = *Error ) @@ -43085,12 +43094,12 @@ func (s *Server) handleTestRequestRequiredStringUintRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint(ctx, request) + response, err = s.h.TestRequestRequiredStringUUID(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint(ctx, request) + response, err = s.h.TestRequestRequiredStringUUID(ctx, request) } if err != nil { recordError("Internal", err) @@ -43098,7 +43107,7 @@ func (s *Server) handleTestRequestRequiredStringUintRequest(args [0]string, args return } - if err := encodeTestRequestRequiredStringUintResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43107,18 +43116,18 @@ func (s *Server) handleTestRequestRequiredStringUintRequest(args [0]string, args } } -// handleTestRequestRequiredStringUint16Request handles test_request_required_string_uint16 operation. +// handleTestRequestRequiredStringUUIDArrayRequest handles test_request_required_string_uuid_array operation. // -// POST /test_request_required_string_uint16 -func (s *Server) handleTestRequestRequiredStringUint16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_array +func (s *Server) handleTestRequestRequiredStringUUIDArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint16"), + otelogen.OperationID("test_request_required_string_uuid_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint16"), + semconv.HTTPRouteKey.String("/test_request_required_string_uuid_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43143,11 +43152,11 @@ func (s *Server) handleTestRequestRequiredStringUint16Request(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint16", - ID: "test_request_required_string_uint16", + Name: "TestRequestRequiredStringUUIDArray", + ID: "test_request_required_string_uuid_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint16Request(r) + request, close, err := s.decodeTestRequestRequiredStringUUIDArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43167,16 +43176,16 @@ func (s *Server) handleTestRequestRequiredStringUint16Request(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint16", + OperationName: "TestRequestRequiredStringUUIDArray", OperationSummary: "", - OperationID: "test_request_required_string_uint16", + OperationID: "test_request_required_string_uuid_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = uint16 + Request = []uuid.UUID Params = struct{} Response = *Error ) @@ -43189,12 +43198,12 @@ func (s *Server) handleTestRequestRequiredStringUint16Request(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint16(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint16(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43202,7 +43211,7 @@ func (s *Server) handleTestRequestRequiredStringUint16Request(args [0]string, ar return } - if err := encodeTestRequestRequiredStringUint16Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43211,18 +43220,18 @@ func (s *Server) handleTestRequestRequiredStringUint16Request(args [0]string, ar } } -// handleTestRequestRequiredStringUint16ArrayRequest handles test_request_required_string_uint16_array operation. +// handleTestRequestRequiredStringUUIDArrayArrayRequest handles test_request_required_string_uuid_array_array operation. // -// POST /test_request_required_string_uint16_array -func (s *Server) handleTestRequestRequiredStringUint16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_array_array +func (s *Server) handleTestRequestRequiredStringUUIDArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint16_array"), + otelogen.OperationID("test_request_required_string_uuid_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint16_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uuid_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43247,11 +43256,11 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint16Array", - ID: "test_request_required_string_uint16_array", + Name: "TestRequestRequiredStringUUIDArrayArray", + ID: "test_request_required_string_uuid_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint16ArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUUIDArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43271,16 +43280,16 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint16Array", + OperationName: "TestRequestRequiredStringUUIDArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint16_array", + OperationID: "test_request_required_string_uuid_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint16 + Request = [][]uuid.UUID Params = struct{} Response = *Error ) @@ -43293,12 +43302,12 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint16Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint16Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43306,7 +43315,7 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringUint16ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43315,18 +43324,18 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayRequest(args [0]strin } } -// handleTestRequestRequiredStringUint16ArrayArrayRequest handles test_request_required_string_uint16_array_array operation. +// handleTestRequestRequiredStringUUIDNullableRequest handles test_request_required_string_uuid_nullable operation. // -// POST /test_request_required_string_uint16_array_array -func (s *Server) handleTestRequestRequiredStringUint16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_nullable +func (s *Server) handleTestRequestRequiredStringUUIDNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint16_array_array"), + otelogen.OperationID("test_request_required_string_uuid_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint16_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uuid_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43351,11 +43360,11 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint16ArrayArray", - ID: "test_request_required_string_uint16_array_array", + Name: "TestRequestRequiredStringUUIDNullable", + ID: "test_request_required_string_uuid_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUint16ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUUIDNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43375,16 +43384,16 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint16ArrayArray", + OperationName: "TestRequestRequiredStringUUIDNullable", OperationSummary: "", - OperationID: "test_request_required_string_uint16_array_array", + OperationID: "test_request_required_string_uuid_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint16 + Request = NilUUID Params = struct{} Response = *Error ) @@ -43397,12 +43406,12 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint16ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint16ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -43410,7 +43419,7 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringUint16ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43419,18 +43428,18 @@ func (s *Server) handleTestRequestRequiredStringUint16ArrayArrayRequest(args [0] } } -// handleTestRequestRequiredStringUint16NullableRequest handles test_request_required_string_uint16_nullable operation. +// handleTestRequestRequiredStringUUIDNullableArrayRequest handles test_request_required_string_uuid_nullable_array operation. // -// POST /test_request_required_string_uint16_nullable -func (s *Server) handleTestRequestRequiredStringUint16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_nullable_array +func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint16_nullable"), + otelogen.OperationID("test_request_required_string_uuid_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint16_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_uuid_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43455,11 +43464,11 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint16Nullable", - ID: "test_request_required_string_uint16_nullable", + Name: "TestRequestRequiredStringUUIDNullableArray", + ID: "test_request_required_string_uuid_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint16NullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43479,16 +43488,16 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint16Nullable", + OperationName: "TestRequestRequiredStringUUIDNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_uint16_nullable", + OperationID: "test_request_required_string_uuid_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUint16 + Request = []NilUUID Params = struct{} Response = *Error ) @@ -43501,12 +43510,12 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint16Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint16Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43514,7 +43523,7 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUint16NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43523,18 +43532,18 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableRequest(args [0]st } } -// handleTestRequestRequiredStringUint16NullableArrayRequest handles test_request_required_string_uint16_nullable_array operation. +// handleTestRequestRequiredStringUUIDNullableArrayArrayRequest handles test_request_required_string_uuid_nullable_array_array operation. // -// POST /test_request_required_string_uint16_nullable_array -func (s *Server) handleTestRequestRequiredStringUint16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uuid_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUUIDNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint16_nullable_array"), + otelogen.OperationID("test_request_required_string_uuid_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint16_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uuid_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUUIDNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43559,11 +43568,11 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint16NullableArray", - ID: "test_request_required_string_uint16_nullable_array", + Name: "TestRequestRequiredStringUUIDNullableArrayArray", + ID: "test_request_required_string_uuid_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint16NullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUUIDNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43583,16 +43592,16 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint16NullableArray", + OperationName: "TestRequestRequiredStringUUIDNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint16_nullable_array", + OperationID: "test_request_required_string_uuid_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint16 + Request = [][]NilUUID Params = struct{} Response = *Error ) @@ -43605,12 +43614,12 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint16NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint16NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUUIDNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -43618,7 +43627,7 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayRequest(args return } - if err := encodeTestRequestRequiredStringUint16NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43627,18 +43636,18 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayRequest(args } } -// handleTestRequestRequiredStringUint16NullableArrayArrayRequest handles test_request_required_string_uint16_nullable_array_array operation. +// handleTestRequestRequiredStringUintRequest handles test_request_required_string_uint operation. // -// POST /test_request_required_string_uint16_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUint16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint +func (s *Server) handleTestRequestRequiredStringUintRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint16_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uint"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint16_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43663,11 +43672,11 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint16NullableArrayArray", - ID: "test_request_required_string_uint16_nullable_array_array", + Name: "TestRequestRequiredStringUint", + ID: "test_request_required_string_uint", } ) - request, close, err := s.decodeTestRequestRequiredStringUint16NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUintRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43687,16 +43696,16 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint16NullableArrayArray", + OperationName: "TestRequestRequiredStringUint", OperationSummary: "", - OperationID: "test_request_required_string_uint16_nullable_array_array", + OperationID: "test_request_required_string_uint", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint16 + Request = uint Params = struct{} Response = *Error ) @@ -43709,12 +43718,12 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint16NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint16NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint(ctx, request) } if err != nil { recordError("Internal", err) @@ -43722,7 +43731,7 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayArrayRequest( return } - if err := encodeTestRequestRequiredStringUint16NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUintResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43731,18 +43740,18 @@ func (s *Server) handleTestRequestRequiredStringUint16NullableArrayArrayRequest( } } -// handleTestRequestRequiredStringUint32Request handles test_request_required_string_uint32 operation. +// handleTestRequestRequiredStringUint16Request handles test_request_required_string_uint16 operation. // -// POST /test_request_required_string_uint32 -func (s *Server) handleTestRequestRequiredStringUint32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint16 +func (s *Server) handleTestRequestRequiredStringUint16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint32"), + otelogen.OperationID("test_request_required_string_uint16"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint32"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint16"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43767,11 +43776,11 @@ func (s *Server) handleTestRequestRequiredStringUint32Request(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint32", - ID: "test_request_required_string_uint32", + Name: "TestRequestRequiredStringUint16", + ID: "test_request_required_string_uint16", } ) - request, close, err := s.decodeTestRequestRequiredStringUint32Request(r) + request, close, err := s.decodeTestRequestRequiredStringUint16Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43791,16 +43800,16 @@ func (s *Server) handleTestRequestRequiredStringUint32Request(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint32", + OperationName: "TestRequestRequiredStringUint16", OperationSummary: "", - OperationID: "test_request_required_string_uint32", + OperationID: "test_request_required_string_uint16", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = uint32 + Request = uint16 Params = struct{} Response = *Error ) @@ -43813,12 +43822,12 @@ func (s *Server) handleTestRequestRequiredStringUint32Request(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint32(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint32(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16(ctx, request) } if err != nil { recordError("Internal", err) @@ -43826,7 +43835,7 @@ func (s *Server) handleTestRequestRequiredStringUint32Request(args [0]string, ar return } - if err := encodeTestRequestRequiredStringUint32Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint16Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43835,18 +43844,18 @@ func (s *Server) handleTestRequestRequiredStringUint32Request(args [0]string, ar } } -// handleTestRequestRequiredStringUint32ArrayRequest handles test_request_required_string_uint32_array operation. +// handleTestRequestRequiredStringUint16ArrayRequest handles test_request_required_string_uint16_array operation. // -// POST /test_request_required_string_uint32_array -func (s *Server) handleTestRequestRequiredStringUint32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint16_array +func (s *Server) handleTestRequestRequiredStringUint16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint32_array"), + otelogen.OperationID("test_request_required_string_uint16_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint32_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint16_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43871,11 +43880,11 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint32Array", - ID: "test_request_required_string_uint32_array", + Name: "TestRequestRequiredStringUint16Array", + ID: "test_request_required_string_uint16_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint32ArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint16ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43895,16 +43904,16 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint32Array", + OperationName: "TestRequestRequiredStringUint16Array", OperationSummary: "", - OperationID: "test_request_required_string_uint32_array", + OperationID: "test_request_required_string_uint16_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint32 + Request = []uint16 Params = struct{} Response = *Error ) @@ -43917,12 +43926,12 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint32Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint32Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -43930,7 +43939,7 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringUint32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint16ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -43939,18 +43948,18 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayRequest(args [0]strin } } -// handleTestRequestRequiredStringUint32ArrayArrayRequest handles test_request_required_string_uint32_array_array operation. +// handleTestRequestRequiredStringUint16ArrayArrayRequest handles test_request_required_string_uint16_array_array operation. // -// POST /test_request_required_string_uint32_array_array -func (s *Server) handleTestRequestRequiredStringUint32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint16_array_array +func (s *Server) handleTestRequestRequiredStringUint16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint32_array_array"), + otelogen.OperationID("test_request_required_string_uint16_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint32_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint16_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -43975,11 +43984,11 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint32ArrayArray", - ID: "test_request_required_string_uint32_array_array", + Name: "TestRequestRequiredStringUint16ArrayArray", + ID: "test_request_required_string_uint16_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint32ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint16ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -43999,16 +44008,16 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint32ArrayArray", + OperationName: "TestRequestRequiredStringUint16ArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint32_array_array", + OperationID: "test_request_required_string_uint16_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint32 + Request = [][]uint16 Params = struct{} Response = *Error ) @@ -44021,12 +44030,12 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint32ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint32ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44034,7 +44043,7 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringUint32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint16ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44043,18 +44052,18 @@ func (s *Server) handleTestRequestRequiredStringUint32ArrayArrayRequest(args [0] } } -// handleTestRequestRequiredStringUint32NullableRequest handles test_request_required_string_uint32_nullable operation. +// handleTestRequestRequiredStringUint16NullableRequest handles test_request_required_string_uint16_nullable operation. // -// POST /test_request_required_string_uint32_nullable -func (s *Server) handleTestRequestRequiredStringUint32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint16_nullable +func (s *Server) handleTestRequestRequiredStringUint16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint32_nullable"), + otelogen.OperationID("test_request_required_string_uint16_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint32_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint16_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44079,11 +44088,11 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint32Nullable", - ID: "test_request_required_string_uint32_nullable", + Name: "TestRequestRequiredStringUint16Nullable", + ID: "test_request_required_string_uint16_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUint32NullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint16NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44103,16 +44112,16 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint32Nullable", + OperationName: "TestRequestRequiredStringUint16Nullable", OperationSummary: "", - OperationID: "test_request_required_string_uint32_nullable", + OperationID: "test_request_required_string_uint16_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUint32 + Request = NilStringUint16 Params = struct{} Response = *Error ) @@ -44125,12 +44134,12 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint32Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint32Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -44138,7 +44147,7 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUint32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint16NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44147,18 +44156,18 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableRequest(args [0]st } } -// handleTestRequestRequiredStringUint32NullableArrayRequest handles test_request_required_string_uint32_nullable_array operation. +// handleTestRequestRequiredStringUint16NullableArrayRequest handles test_request_required_string_uint16_nullable_array operation. // -// POST /test_request_required_string_uint32_nullable_array -func (s *Server) handleTestRequestRequiredStringUint32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint16_nullable_array +func (s *Server) handleTestRequestRequiredStringUint16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint32_nullable_array"), + otelogen.OperationID("test_request_required_string_uint16_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint32_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint16_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44183,11 +44192,11 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint32NullableArray", - ID: "test_request_required_string_uint32_nullable_array", + Name: "TestRequestRequiredStringUint16NullableArray", + ID: "test_request_required_string_uint16_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint32NullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint16NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44207,16 +44216,16 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint32NullableArray", + OperationName: "TestRequestRequiredStringUint16NullableArray", OperationSummary: "", - OperationID: "test_request_required_string_uint32_nullable_array", + OperationID: "test_request_required_string_uint16_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint32 + Request = []NilStringUint16 Params = struct{} Response = *Error ) @@ -44229,12 +44238,12 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint32NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint32NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44242,7 +44251,7 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayRequest(args return } - if err := encodeTestRequestRequiredStringUint32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint16NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44251,18 +44260,18 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayRequest(args } } -// handleTestRequestRequiredStringUint32NullableArrayArrayRequest handles test_request_required_string_uint32_nullable_array_array operation. +// handleTestRequestRequiredStringUint16NullableArrayArrayRequest handles test_request_required_string_uint16_nullable_array_array operation. // -// POST /test_request_required_string_uint32_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUint32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint16_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUint16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint32_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uint16_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint16_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint16NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44287,11 +44296,11 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint32NullableArrayArray", - ID: "test_request_required_string_uint32_nullable_array_array", + Name: "TestRequestRequiredStringUint16NullableArrayArray", + ID: "test_request_required_string_uint16_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint16NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44311,16 +44320,16 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint32NullableArrayArray", + OperationName: "TestRequestRequiredStringUint16NullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint32_nullable_array_array", + OperationID: "test_request_required_string_uint16_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint32 + Request = [][]NilStringUint16 Params = struct{} Response = *Error ) @@ -44333,12 +44342,12 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint16NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44346,7 +44355,7 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayArrayRequest( return } - if err := encodeTestRequestRequiredStringUint32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint16NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44355,18 +44364,18 @@ func (s *Server) handleTestRequestRequiredStringUint32NullableArrayArrayRequest( } } -// handleTestRequestRequiredStringUint64Request handles test_request_required_string_uint64 operation. +// handleTestRequestRequiredStringUint32Request handles test_request_required_string_uint32 operation. // -// POST /test_request_required_string_uint64 -func (s *Server) handleTestRequestRequiredStringUint64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint32 +func (s *Server) handleTestRequestRequiredStringUint32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint64"), + otelogen.OperationID("test_request_required_string_uint32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint64"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44391,11 +44400,11 @@ func (s *Server) handleTestRequestRequiredStringUint64Request(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint64", - ID: "test_request_required_string_uint64", + Name: "TestRequestRequiredStringUint32", + ID: "test_request_required_string_uint32", } ) - request, close, err := s.decodeTestRequestRequiredStringUint64Request(r) + request, close, err := s.decodeTestRequestRequiredStringUint32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44415,16 +44424,16 @@ func (s *Server) handleTestRequestRequiredStringUint64Request(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint64", + OperationName: "TestRequestRequiredStringUint32", OperationSummary: "", - OperationID: "test_request_required_string_uint64", + OperationID: "test_request_required_string_uint32", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = uint64 + Request = uint32 Params = struct{} Response = *Error ) @@ -44437,12 +44446,12 @@ func (s *Server) handleTestRequestRequiredStringUint64Request(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint64(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint64(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32(ctx, request) } if err != nil { recordError("Internal", err) @@ -44450,7 +44459,7 @@ func (s *Server) handleTestRequestRequiredStringUint64Request(args [0]string, ar return } - if err := encodeTestRequestRequiredStringUint64Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44459,18 +44468,18 @@ func (s *Server) handleTestRequestRequiredStringUint64Request(args [0]string, ar } } -// handleTestRequestRequiredStringUint64ArrayRequest handles test_request_required_string_uint64_array operation. +// handleTestRequestRequiredStringUint32ArrayRequest handles test_request_required_string_uint32_array operation. // -// POST /test_request_required_string_uint64_array -func (s *Server) handleTestRequestRequiredStringUint64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint32_array +func (s *Server) handleTestRequestRequiredStringUint32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint64_array"), + otelogen.OperationID("test_request_required_string_uint32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint64_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44495,11 +44504,11 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint64Array", - ID: "test_request_required_string_uint64_array", + Name: "TestRequestRequiredStringUint32Array", + ID: "test_request_required_string_uint32_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint64ArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44519,16 +44528,16 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint64Array", + OperationName: "TestRequestRequiredStringUint32Array", OperationSummary: "", - OperationID: "test_request_required_string_uint64_array", + OperationID: "test_request_required_string_uint32_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint64 + Request = []uint32 Params = struct{} Response = *Error ) @@ -44541,12 +44550,12 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint64Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint64Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -44554,7 +44563,7 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringUint64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44563,18 +44572,18 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayRequest(args [0]strin } } -// handleTestRequestRequiredStringUint64ArrayArrayRequest handles test_request_required_string_uint64_array_array operation. +// handleTestRequestRequiredStringUint32ArrayArrayRequest handles test_request_required_string_uint32_array_array operation. // -// POST /test_request_required_string_uint64_array_array -func (s *Server) handleTestRequestRequiredStringUint64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint32_array_array +func (s *Server) handleTestRequestRequiredStringUint32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint64_array_array"), + otelogen.OperationID("test_request_required_string_uint32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint64_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44599,11 +44608,11 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint64ArrayArray", - ID: "test_request_required_string_uint64_array_array", + Name: "TestRequestRequiredStringUint32ArrayArray", + ID: "test_request_required_string_uint32_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint64ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44623,16 +44632,16 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint64ArrayArray", + OperationName: "TestRequestRequiredStringUint32ArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint64_array_array", + OperationID: "test_request_required_string_uint32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint64 + Request = [][]uint32 Params = struct{} Response = *Error ) @@ -44645,12 +44654,12 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint64ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint64ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44658,7 +44667,7 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringUint64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44667,18 +44676,18 @@ func (s *Server) handleTestRequestRequiredStringUint64ArrayArrayRequest(args [0] } } -// handleTestRequestRequiredStringUint64NullableRequest handles test_request_required_string_uint64_nullable operation. +// handleTestRequestRequiredStringUint32NullableRequest handles test_request_required_string_uint32_nullable operation. // -// POST /test_request_required_string_uint64_nullable -func (s *Server) handleTestRequestRequiredStringUint64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint32_nullable +func (s *Server) handleTestRequestRequiredStringUint32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint64_nullable"), + otelogen.OperationID("test_request_required_string_uint32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint64_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44703,11 +44712,11 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint64Nullable", - ID: "test_request_required_string_uint64_nullable", + Name: "TestRequestRequiredStringUint32Nullable", + ID: "test_request_required_string_uint32_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUint64NullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44727,16 +44736,16 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint64Nullable", + OperationName: "TestRequestRequiredStringUint32Nullable", OperationSummary: "", - OperationID: "test_request_required_string_uint64_nullable", + OperationID: "test_request_required_string_uint32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUint64 + Request = NilStringUint32 Params = struct{} Response = *Error ) @@ -44749,12 +44758,12 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint64Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint64Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -44762,7 +44771,7 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUint64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44771,18 +44780,18 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableRequest(args [0]st } } -// handleTestRequestRequiredStringUint64NullableArrayRequest handles test_request_required_string_uint64_nullable_array operation. +// handleTestRequestRequiredStringUint32NullableArrayRequest handles test_request_required_string_uint32_nullable_array operation. // -// POST /test_request_required_string_uint64_nullable_array -func (s *Server) handleTestRequestRequiredStringUint64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint32_nullable_array +func (s *Server) handleTestRequestRequiredStringUint32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint64_nullable_array"), + otelogen.OperationID("test_request_required_string_uint32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint64_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44807,11 +44816,11 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint64NullableArray", - ID: "test_request_required_string_uint64_nullable_array", + Name: "TestRequestRequiredStringUint32NullableArray", + ID: "test_request_required_string_uint32_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint64NullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44831,16 +44840,16 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint64NullableArray", + OperationName: "TestRequestRequiredStringUint32NullableArray", OperationSummary: "", - OperationID: "test_request_required_string_uint64_nullable_array", + OperationID: "test_request_required_string_uint32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint64 + Request = []NilStringUint32 Params = struct{} Response = *Error ) @@ -44853,12 +44862,12 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint64NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint64NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44866,7 +44875,7 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayRequest(args return } - if err := encodeTestRequestRequiredStringUint64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44875,18 +44884,18 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayRequest(args } } -// handleTestRequestRequiredStringUint64NullableArrayArrayRequest handles test_request_required_string_uint64_nullable_array_array operation. +// handleTestRequestRequiredStringUint32NullableArrayArrayRequest handles test_request_required_string_uint32_nullable_array_array operation. // -// POST /test_request_required_string_uint64_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUint64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint32_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUint32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint64_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uint32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -44911,11 +44920,11 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint64NullableArrayArray", - ID: "test_request_required_string_uint64_nullable_array_array", + Name: "TestRequestRequiredStringUint32NullableArrayArray", + ID: "test_request_required_string_uint32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -44935,16 +44944,16 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint64NullableArrayArray", + OperationName: "TestRequestRequiredStringUint32NullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint64_nullable_array_array", + OperationID: "test_request_required_string_uint32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint64 + Request = [][]NilStringUint32 Params = struct{} Response = *Error ) @@ -44957,12 +44966,12 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -44970,7 +44979,7 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayArrayRequest( return } - if err := encodeTestRequestRequiredStringUint64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -44979,18 +44988,18 @@ func (s *Server) handleTestRequestRequiredStringUint64NullableArrayArrayRequest( } } -// handleTestRequestRequiredStringUint8Request handles test_request_required_string_uint8 operation. +// handleTestRequestRequiredStringUint64Request handles test_request_required_string_uint64 operation. // -// POST /test_request_required_string_uint8 -func (s *Server) handleTestRequestRequiredStringUint8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint64 +func (s *Server) handleTestRequestRequiredStringUint64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint8"), + otelogen.OperationID("test_request_required_string_uint64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint8"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45015,11 +45024,11 @@ func (s *Server) handleTestRequestRequiredStringUint8Request(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint8", - ID: "test_request_required_string_uint8", + Name: "TestRequestRequiredStringUint64", + ID: "test_request_required_string_uint64", } ) - request, close, err := s.decodeTestRequestRequiredStringUint8Request(r) + request, close, err := s.decodeTestRequestRequiredStringUint64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45039,16 +45048,16 @@ func (s *Server) handleTestRequestRequiredStringUint8Request(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint8", + OperationName: "TestRequestRequiredStringUint64", OperationSummary: "", - OperationID: "test_request_required_string_uint8", + OperationID: "test_request_required_string_uint64", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = uint8 + Request = uint64 Params = struct{} Response = *Error ) @@ -45061,12 +45070,12 @@ func (s *Server) handleTestRequestRequiredStringUint8Request(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint8(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint8(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64(ctx, request) } if err != nil { recordError("Internal", err) @@ -45074,7 +45083,7 @@ func (s *Server) handleTestRequestRequiredStringUint8Request(args [0]string, arg return } - if err := encodeTestRequestRequiredStringUint8Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45083,18 +45092,18 @@ func (s *Server) handleTestRequestRequiredStringUint8Request(args [0]string, arg } } -// handleTestRequestRequiredStringUint8ArrayRequest handles test_request_required_string_uint8_array operation. +// handleTestRequestRequiredStringUint64ArrayRequest handles test_request_required_string_uint64_array operation. // -// POST /test_request_required_string_uint8_array -func (s *Server) handleTestRequestRequiredStringUint8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint64_array +func (s *Server) handleTestRequestRequiredStringUint64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint8_array"), + otelogen.OperationID("test_request_required_string_uint64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint8_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45119,11 +45128,11 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint8Array", - ID: "test_request_required_string_uint8_array", + Name: "TestRequestRequiredStringUint64Array", + ID: "test_request_required_string_uint64_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint8ArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45143,16 +45152,16 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint8Array", + OperationName: "TestRequestRequiredStringUint64Array", OperationSummary: "", - OperationID: "test_request_required_string_uint8_array", + OperationID: "test_request_required_string_uint64_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint8 + Request = []uint64 Params = struct{} Response = *Error ) @@ -45165,12 +45174,12 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint8Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint8Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -45178,7 +45187,7 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayRequest(args [0]string return } - if err := encodeTestRequestRequiredStringUint8ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45187,18 +45196,18 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayRequest(args [0]string } } -// handleTestRequestRequiredStringUint8ArrayArrayRequest handles test_request_required_string_uint8_array_array operation. +// handleTestRequestRequiredStringUint64ArrayArrayRequest handles test_request_required_string_uint64_array_array operation. // -// POST /test_request_required_string_uint8_array_array -func (s *Server) handleTestRequestRequiredStringUint8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint64_array_array +func (s *Server) handleTestRequestRequiredStringUint64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint8_array_array"), + otelogen.OperationID("test_request_required_string_uint64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint8_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45223,11 +45232,11 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint8ArrayArray", - ID: "test_request_required_string_uint8_array_array", + Name: "TestRequestRequiredStringUint64ArrayArray", + ID: "test_request_required_string_uint64_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint8ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45247,16 +45256,16 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint8ArrayArray", + OperationName: "TestRequestRequiredStringUint64ArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint8_array_array", + OperationID: "test_request_required_string_uint64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint8 + Request = [][]uint64 Params = struct{} Response = *Error ) @@ -45269,12 +45278,12 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint8ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint8ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45282,7 +45291,7 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayArrayRequest(args [0]s return } - if err := encodeTestRequestRequiredStringUint8ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45291,18 +45300,18 @@ func (s *Server) handleTestRequestRequiredStringUint8ArrayArrayRequest(args [0]s } } -// handleTestRequestRequiredStringUint8NullableRequest handles test_request_required_string_uint8_nullable operation. +// handleTestRequestRequiredStringUint64NullableRequest handles test_request_required_string_uint64_nullable operation. // -// POST /test_request_required_string_uint8_nullable -func (s *Server) handleTestRequestRequiredStringUint8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint64_nullable +func (s *Server) handleTestRequestRequiredStringUint64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint8_nullable"), + otelogen.OperationID("test_request_required_string_uint64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint8_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45327,11 +45336,11 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint8Nullable", - ID: "test_request_required_string_uint8_nullable", + Name: "TestRequestRequiredStringUint64Nullable", + ID: "test_request_required_string_uint64_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUint8NullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45351,16 +45360,16 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint8Nullable", + OperationName: "TestRequestRequiredStringUint64Nullable", OperationSummary: "", - OperationID: "test_request_required_string_uint8_nullable", + OperationID: "test_request_required_string_uint64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUint8 + Request = NilStringUint64 Params = struct{} Response = *Error ) @@ -45373,12 +45382,12 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint8Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint8Nullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -45386,7 +45395,7 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableRequest(args [0]str return } - if err := encodeTestRequestRequiredStringUint8NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45395,18 +45404,18 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableRequest(args [0]str } } -// handleTestRequestRequiredStringUint8NullableArrayRequest handles test_request_required_string_uint8_nullable_array operation. +// handleTestRequestRequiredStringUint64NullableArrayRequest handles test_request_required_string_uint64_nullable_array operation. // -// POST /test_request_required_string_uint8_nullable_array -func (s *Server) handleTestRequestRequiredStringUint8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint64_nullable_array +func (s *Server) handleTestRequestRequiredStringUint64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint8_nullable_array"), + otelogen.OperationID("test_request_required_string_uint64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint8_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45431,11 +45440,11 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint8NullableArray", - ID: "test_request_required_string_uint8_nullable_array", + Name: "TestRequestRequiredStringUint64NullableArray", + ID: "test_request_required_string_uint64_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint8NullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45455,16 +45464,16 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint8NullableArray", + OperationName: "TestRequestRequiredStringUint64NullableArray", OperationSummary: "", - OperationID: "test_request_required_string_uint8_nullable_array", + OperationID: "test_request_required_string_uint64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint8 + Request = []NilStringUint64 Params = struct{} Response = *Error ) @@ -45477,12 +45486,12 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint8NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint8NullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45490,7 +45499,7 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringUint8NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45499,18 +45508,18 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayRequest(args [ } } -// handleTestRequestRequiredStringUint8NullableArrayArrayRequest handles test_request_required_string_uint8_nullable_array_array operation. +// handleTestRequestRequiredStringUint64NullableArrayArrayRequest handles test_request_required_string_uint64_nullable_array_array operation. // -// POST /test_request_required_string_uint8_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUint8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint64_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUint64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint8_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uint64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint8_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45535,11 +45544,11 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUint8NullableArrayArray", - ID: "test_request_required_string_uint8_nullable_array_array", + Name: "TestRequestRequiredStringUint64NullableArrayArray", + ID: "test_request_required_string_uint64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUint8NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45559,16 +45568,16 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayArrayRequest(a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUint8NullableArrayArray", + OperationName: "TestRequestRequiredStringUint64NullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint8_nullable_array_array", + OperationID: "test_request_required_string_uint64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint8 + Request = [][]NilStringUint64 Params = struct{} Response = *Error ) @@ -45581,12 +45590,12 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUint8NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUint8NullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45594,7 +45603,7 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayArrayRequest(a return } - if err := encodeTestRequestRequiredStringUint8NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45603,18 +45612,18 @@ func (s *Server) handleTestRequestRequiredStringUint8NullableArrayArrayRequest(a } } -// handleTestRequestRequiredStringUintArrayRequest handles test_request_required_string_uint_array operation. +// handleTestRequestRequiredStringUint8Request handles test_request_required_string_uint8 operation. // -// POST /test_request_required_string_uint_array -func (s *Server) handleTestRequestRequiredStringUintArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint8 +func (s *Server) handleTestRequestRequiredStringUint8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint_array"), + otelogen.OperationID("test_request_required_string_uint8"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint8"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUintArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45639,11 +45648,11 @@ func (s *Server) handleTestRequestRequiredStringUintArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUintArray", - ID: "test_request_required_string_uint_array", + Name: "TestRequestRequiredStringUint8", + ID: "test_request_required_string_uint8", } ) - request, close, err := s.decodeTestRequestRequiredStringUintArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint8Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45663,16 +45672,16 @@ func (s *Server) handleTestRequestRequiredStringUintArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUintArray", + OperationName: "TestRequestRequiredStringUint8", OperationSummary: "", - OperationID: "test_request_required_string_uint_array", + OperationID: "test_request_required_string_uint8", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint + Request = uint8 Params = struct{} Response = *Error ) @@ -45685,12 +45694,12 @@ func (s *Server) handleTestRequestRequiredStringUintArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUintArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUintArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8(ctx, request) } if err != nil { recordError("Internal", err) @@ -45698,7 +45707,7 @@ func (s *Server) handleTestRequestRequiredStringUintArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUintArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint8Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45707,18 +45716,18 @@ func (s *Server) handleTestRequestRequiredStringUintArrayRequest(args [0]string, } } -// handleTestRequestRequiredStringUintArrayArrayRequest handles test_request_required_string_uint_array_array operation. +// handleTestRequestRequiredStringUint8ArrayRequest handles test_request_required_string_uint8_array operation. // -// POST /test_request_required_string_uint_array_array -func (s *Server) handleTestRequestRequiredStringUintArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint8_array +func (s *Server) handleTestRequestRequiredStringUint8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint_array_array"), + otelogen.OperationID("test_request_required_string_uint8_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint8_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUintArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45743,11 +45752,11 @@ func (s *Server) handleTestRequestRequiredStringUintArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUintArrayArray", - ID: "test_request_required_string_uint_array_array", + Name: "TestRequestRequiredStringUint8Array", + ID: "test_request_required_string_uint8_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUintArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint8ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45767,16 +45776,16 @@ func (s *Server) handleTestRequestRequiredStringUintArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUintArrayArray", + OperationName: "TestRequestRequiredStringUint8Array", OperationSummary: "", - OperationID: "test_request_required_string_uint_array_array", + OperationID: "test_request_required_string_uint8_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint + Request = []uint8 Params = struct{} Response = *Error ) @@ -45789,12 +45798,12 @@ func (s *Server) handleTestRequestRequiredStringUintArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUintArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUintArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -45802,7 +45811,7 @@ func (s *Server) handleTestRequestRequiredStringUintArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUintArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint8ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45811,18 +45820,18 @@ func (s *Server) handleTestRequestRequiredStringUintArrayArrayRequest(args [0]st } } -// handleTestRequestRequiredStringUintNullableRequest handles test_request_required_string_uint_nullable operation. +// handleTestRequestRequiredStringUint8ArrayArrayRequest handles test_request_required_string_uint8_array_array operation. // -// POST /test_request_required_string_uint_nullable -func (s *Server) handleTestRequestRequiredStringUintNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint8_array_array +func (s *Server) handleTestRequestRequiredStringUint8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint_nullable"), + otelogen.OperationID("test_request_required_string_uint8_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint8_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUintNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45847,11 +45856,11 @@ func (s *Server) handleTestRequestRequiredStringUintNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUintNullable", - ID: "test_request_required_string_uint_nullable", + Name: "TestRequestRequiredStringUint8ArrayArray", + ID: "test_request_required_string_uint8_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUintNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint8ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45871,16 +45880,16 @@ func (s *Server) handleTestRequestRequiredStringUintNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUintNullable", + OperationName: "TestRequestRequiredStringUint8ArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_uint_nullable", + OperationID: "test_request_required_string_uint8_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUint + Request = [][]uint8 Params = struct{} Response = *Error ) @@ -45893,12 +45902,12 @@ func (s *Server) handleTestRequestRequiredStringUintNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUintNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUintNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -45906,7 +45915,7 @@ func (s *Server) handleTestRequestRequiredStringUintNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringUintNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint8ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -45915,18 +45924,18 @@ func (s *Server) handleTestRequestRequiredStringUintNullableRequest(args [0]stri } } -// handleTestRequestRequiredStringUintNullableArrayRequest handles test_request_required_string_uint_nullable_array operation. +// handleTestRequestRequiredStringUint8NullableRequest handles test_request_required_string_uint8_nullable operation. // -// POST /test_request_required_string_uint_nullable_array -func (s *Server) handleTestRequestRequiredStringUintNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint8_nullable +func (s *Server) handleTestRequestRequiredStringUint8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint_nullable_array"), + otelogen.OperationID("test_request_required_string_uint8_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint8_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUintNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -45951,11 +45960,11 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUintNullableArray", - ID: "test_request_required_string_uint_nullable_array", + Name: "TestRequestRequiredStringUint8Nullable", + ID: "test_request_required_string_uint8_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUintNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint8NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -45975,16 +45984,16 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUintNullableArray", + OperationName: "TestRequestRequiredStringUint8Nullable", OperationSummary: "", - OperationID: "test_request_required_string_uint_nullable_array", + OperationID: "test_request_required_string_uint8_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint + Request = NilStringUint8 Params = struct{} Response = *Error ) @@ -45997,12 +46006,12 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUintNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUintNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -46010,7 +46019,7 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringUintNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint8NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46019,18 +46028,18 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayRequest(args [0 } } -// handleTestRequestRequiredStringUintNullableArrayArrayRequest handles test_request_required_string_uint_nullable_array_array operation. +// handleTestRequestRequiredStringUint8NullableArrayRequest handles test_request_required_string_uint8_nullable_array operation. // -// POST /test_request_required_string_uint_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUintNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint8_nullable_array +func (s *Server) handleTestRequestRequiredStringUint8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_uint_nullable_array_array"), + otelogen.OperationID("test_request_required_string_uint8_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_uint_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint8_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUintNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46055,11 +46064,11 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUintNullableArrayArray", - ID: "test_request_required_string_uint_nullable_array_array", + Name: "TestRequestRequiredStringUint8NullableArray", + ID: "test_request_required_string_uint8_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUintNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint8NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46079,16 +46088,16 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUintNullableArrayArray", + OperationName: "TestRequestRequiredStringUint8NullableArray", OperationSummary: "", - OperationID: "test_request_required_string_uint_nullable_array_array", + OperationID: "test_request_required_string_uint8_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint + Request = []NilStringUint8 Params = struct{} Response = *Error ) @@ -46101,12 +46110,12 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUintNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUintNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46114,7 +46123,7 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUintNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint8NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46123,18 +46132,18 @@ func (s *Server) handleTestRequestRequiredStringUintNullableArrayArrayRequest(ar } } -// handleTestRequestRequiredStringUnixRequest handles test_request_required_string_unix operation. +// handleTestRequestRequiredStringUint8NullableArrayArrayRequest handles test_request_required_string_uint8_nullable_array_array operation. // -// POST /test_request_required_string_unix -func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint8_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUint8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix"), + otelogen.OperationID("test_request_required_string_uint8_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint8_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnix", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUint8NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46159,11 +46168,11 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnix", - ID: "test_request_required_string_unix", + Name: "TestRequestRequiredStringUint8NullableArrayArray", + ID: "test_request_required_string_uint8_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUint8NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46183,16 +46192,16 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnix", + OperationName: "TestRequestRequiredStringUint8NullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix", + OperationID: "test_request_required_string_uint8_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = time.Time + Request = [][]NilStringUint8 Params = struct{} Response = *Error ) @@ -46205,12 +46214,12 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnix(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnix(ctx, request) + response, err = s.h.TestRequestRequiredStringUint8NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46218,7 +46227,7 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, args return } - if err := encodeTestRequestRequiredStringUnixResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUint8NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46227,18 +46236,18 @@ func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, args } } -// handleTestRequestRequiredStringUnixArrayRequest handles test_request_required_string_unix_array operation. +// handleTestRequestRequiredStringUintArrayRequest handles test_request_required_string_uint_array operation. // -// POST /test_request_required_string_unix_array -func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint_array +func (s *Server) handleTestRequestRequiredStringUintArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_array"), + otelogen.OperationID("test_request_required_string_uint_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUintArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46263,11 +46272,11 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixArray", - ID: "test_request_required_string_unix_array", + Name: "TestRequestRequiredStringUintArray", + ID: "test_request_required_string_uint_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUintArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46287,16 +46296,16 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixArray", + OperationName: "TestRequestRequiredStringUintArray", OperationSummary: "", - OperationID: "test_request_required_string_unix_array", + OperationID: "test_request_required_string_uint_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = []uint Params = struct{} Response = *Error ) @@ -46309,12 +46318,12 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46322,7 +46331,7 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUintArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46331,18 +46340,18 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, } } -// handleTestRequestRequiredStringUnixArrayArrayRequest handles test_request_required_string_unix_array_array operation. +// handleTestRequestRequiredStringUintArrayArrayRequest handles test_request_required_string_uint_array_array operation. // -// POST /test_request_required_string_unix_array_array -func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint_array_array +func (s *Server) handleTestRequestRequiredStringUintArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_array_array"), + otelogen.OperationID("test_request_required_string_uint_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint_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(), "TestRequestRequiredStringUintArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46367,11 +46376,11 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixArrayArray", - ID: "test_request_required_string_unix_array_array", + Name: "TestRequestRequiredStringUintArrayArray", + ID: "test_request_required_string_uint_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUintArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46391,16 +46400,16 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixArrayArray", + OperationName: "TestRequestRequiredStringUintArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix_array_array", + OperationID: "test_request_required_string_uint_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]uint Params = struct{} Response = *Error ) @@ -46413,12 +46422,12 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46426,7 +46435,7 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUnixArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUintArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46435,18 +46444,18 @@ func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]st } } -// handleTestRequestRequiredStringUnixMicroRequest handles test_request_required_string_unix-micro operation. +// handleTestRequestRequiredStringUintNullableRequest handles test_request_required_string_uint_nullable operation. // -// POST /test_request_required_string_unix-micro -func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint_nullable +func (s *Server) handleTestRequestRequiredStringUintNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro"), + otelogen.OperationID("test_request_required_string_uint_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicro", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUintNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46471,11 +46480,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicro", - ID: "test_request_required_string_unix-micro", + Name: "TestRequestRequiredStringUintNullable", + ID: "test_request_required_string_uint_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUintNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46495,16 +46504,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicro", + OperationName: "TestRequestRequiredStringUintNullable", OperationSummary: "", - OperationID: "test_request_required_string_unix-micro", + OperationID: "test_request_required_string_uint_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = time.Time + Request = NilStringUint Params = struct{} Response = *Error ) @@ -46517,12 +46526,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMicro(ctx, request) + response, err = s.h.TestRequestRequiredStringUintNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicro(ctx, request) + response, err = s.h.TestRequestRequiredStringUintNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -46530,7 +46539,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixMicroResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUintNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46539,18 +46548,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, } } -// handleTestRequestRequiredStringUnixMicroArrayRequest handles test_request_required_string_unix-micro_array operation. +// handleTestRequestRequiredStringUintNullableArrayRequest handles test_request_required_string_uint_nullable_array operation. // -// POST /test_request_required_string_unix-micro_array -func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint_nullable_array +func (s *Server) handleTestRequestRequiredStringUintNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_array"), + otelogen.OperationID("test_request_required_string_uint_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint_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(), "TestRequestRequiredStringUintNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46575,11 +46584,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroArray", - ID: "test_request_required_string_unix-micro_array", + Name: "TestRequestRequiredStringUintNullableArray", + ID: "test_request_required_string_uint_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUintNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46599,16 +46608,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroArray", + OperationName: "TestRequestRequiredStringUintNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-micro_array", + OperationID: "test_request_required_string_uint_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = []NilStringUint Params = struct{} Response = *Error ) @@ -46621,12 +46630,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46634,7 +46643,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUnixMicroArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUintNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46643,18 +46652,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]st } } -// handleTestRequestRequiredStringUnixMicroArrayArrayRequest handles test_request_required_string_unix-micro_array_array operation. +// handleTestRequestRequiredStringUintNullableArrayArrayRequest handles test_request_required_string_uint_nullable_array_array operation. // -// POST /test_request_required_string_unix-micro_array_array -func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_uint_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUintNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_uint_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_uint_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(), "TestRequestRequiredStringUintNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46679,11 +46688,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroArrayArray", - ID: "test_request_required_string_unix-micro_array_array", + Name: "TestRequestRequiredStringUintNullableArrayArray", + ID: "test_request_required_string_uint_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUintNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46703,16 +46712,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroArrayArray", + OperationName: "TestRequestRequiredStringUintNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-micro_array_array", + OperationID: "test_request_required_string_uint_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilStringUint Params = struct{} Response = *Error ) @@ -46725,12 +46734,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUintNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46738,7 +46747,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args return } - if err := encodeTestRequestRequiredStringUnixMicroArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUintNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46747,18 +46756,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args } } -// handleTestRequestRequiredStringUnixMicroNullableRequest handles test_request_required_string_unix-micro_nullable operation. +// handleTestRequestRequiredStringUnixRequest handles test_request_required_string_unix operation. // -// POST /test_request_required_string_unix-micro_nullable -func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix +func (s *Server) handleTestRequestRequiredStringUnixRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-micro_nullable"), + otelogen.OperationID("test_request_required_string_unix"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnix", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46783,11 +46792,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroNullable", - ID: "test_request_required_string_unix-micro_nullable", + Name: "TestRequestRequiredStringUnix", + ID: "test_request_required_string_unix", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46807,16 +46816,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroNullable", + OperationName: "TestRequestRequiredStringUnix", OperationSummary: "", - OperationID: "test_request_required_string_unix-micro_nullable", + OperationID: "test_request_required_string_unix", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUnixMicro + Request = time.Time Params = struct{} Response = *Error ) @@ -46829,12 +46838,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnix(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnix(ctx, request) } if err != nil { recordError("Internal", err) @@ -46842,7 +46851,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 return } - if err := encodeTestRequestRequiredStringUnixMicroNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46851,18 +46860,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0 } } -// handleTestRequestRequiredStringUnixMicroNullableArrayRequest handles test_request_required_string_unix-micro_nullable_array operation. +// handleTestRequestRequiredStringUnixArrayRequest handles test_request_required_string_unix_array operation. // -// POST /test_request_required_string_unix-micro_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_array +func (s *Server) handleTestRequestRequiredStringUnixArrayRequest(args [0]string, argsEscaped bool, 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_unix_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46887,11 +46896,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroNullableArray", - ID: "test_request_required_string_unix-micro_nullable_array", + Name: "TestRequestRequiredStringUnixArray", + ID: "test_request_required_string_unix_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -46911,16 +46920,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroNullableArray", + OperationName: "TestRequestRequiredStringUnixArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-micro_nullable_array", + OperationID: "test_request_required_string_unix_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixMicro + Request = []time.Time Params = struct{} Response = *Error ) @@ -46933,12 +46942,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -46946,7 +46955,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUnixMicroNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -46955,18 +46964,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(ar } } -// handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest handles test_request_required_string_unix-micro_nullable_array_array operation. +// handleTestRequestRequiredStringUnixArrayArrayRequest handles test_request_required_string_unix_array_array operation. // -// POST /test_request_required_string_unix-micro_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_array_array +func (s *Server) handleTestRequestRequiredStringUnixArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix_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(), "TestRequestRequiredStringUnixArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -46991,11 +47000,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMicroNullableArrayArray", - ID: "test_request_required_string_unix-micro_nullable_array_array", + Name: "TestRequestRequiredStringUnixArrayArray", + ID: "test_request_required_string_unix_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47015,16 +47024,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMicroNullableArrayArray", + OperationName: "TestRequestRequiredStringUnixArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-micro_nullable_array_array", + OperationID: "test_request_required_string_unix_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixMicro + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -47037,12 +47046,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -47050,7 +47059,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque return } - if err := encodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47059,18 +47068,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayReque } } -// handleTestRequestRequiredStringUnixMilliRequest handles test_request_required_string_unix-milli operation. +// handleTestRequestRequiredStringUnixMicroRequest handles test_request_required_string_unix-micro operation. // -// POST /test_request_required_string_unix-milli -func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro +func (s *Server) handleTestRequestRequiredStringUnixMicroRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli"), + otelogen.OperationID("test_request_required_string_unix-micro"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilli", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicro", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47095,11 +47104,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilli", - ID: "test_request_required_string_unix-milli", + Name: "TestRequestRequiredStringUnixMicro", + ID: "test_request_required_string_unix-micro", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47119,9 +47128,9 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilli", + OperationName: "TestRequestRequiredStringUnixMicro", OperationSummary: "", - OperationID: "test_request_required_string_unix-milli", + OperationID: "test_request_required_string_unix-micro", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -47141,12 +47150,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMilli(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicro(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilli(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicro(ctx, request) } if err != nil { recordError("Internal", err) @@ -47154,7 +47163,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixMilliResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47163,18 +47172,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, } } -// handleTestRequestRequiredStringUnixMilliArrayRequest handles test_request_required_string_unix-milli_array operation. +// handleTestRequestRequiredStringUnixMicroArrayRequest handles test_request_required_string_unix-micro_array operation. // -// POST /test_request_required_string_unix-milli_array -func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_array +func (s *Server) handleTestRequestRequiredStringUnixMicroArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_array"), + otelogen.OperationID("test_request_required_string_unix-micro_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47199,11 +47208,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliArray", - ID: "test_request_required_string_unix-milli_array", + Name: "TestRequestRequiredStringUnixMicroArray", + ID: "test_request_required_string_unix-micro_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47223,9 +47232,9 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliArray", + OperationName: "TestRequestRequiredStringUnixMicroArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-milli_array", + OperationID: "test_request_required_string_unix-micro_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -47245,12 +47254,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -47258,7 +47267,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st return } - if err := encodeTestRequestRequiredStringUnixMilliArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47267,18 +47276,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]st } } -// handleTestRequestRequiredStringUnixMilliArrayArrayRequest handles test_request_required_string_unix-milli_array_array operation. +// handleTestRequestRequiredStringUnixMicroArrayArrayRequest handles test_request_required_string_unix-micro_array_array operation. // -// POST /test_request_required_string_unix-milli_array_array -func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_array_array +func (s *Server) handleTestRequestRequiredStringUnixMicroArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix-micro_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_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(), "TestRequestRequiredStringUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47303,11 +47312,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliArrayArray", - ID: "test_request_required_string_unix-milli_array_array", + Name: "TestRequestRequiredStringUnixMicroArrayArray", + ID: "test_request_required_string_unix-micro_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47327,9 +47336,9 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliArrayArray", + OperationName: "TestRequestRequiredStringUnixMicroArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-milli_array_array", + OperationID: "test_request_required_string_unix-micro_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -47349,12 +47358,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -47362,7 +47371,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args return } - if err := encodeTestRequestRequiredStringUnixMilliArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47371,18 +47380,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args } } -// handleTestRequestRequiredStringUnixMilliNullableRequest handles test_request_required_string_unix-milli_nullable operation. +// handleTestRequestRequiredStringUnixMicroNullableRequest handles test_request_required_string_unix-micro_nullable operation. // -// POST /test_request_required_string_unix-milli_nullable -func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_nullable +func (s *Server) handleTestRequestRequiredStringUnixMicroNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-milli_nullable"), + otelogen.OperationID("test_request_required_string_unix-micro_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47407,11 +47416,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliNullable", - ID: "test_request_required_string_unix-milli_nullable", + Name: "TestRequestRequiredStringUnixMicroNullable", + ID: "test_request_required_string_unix-micro_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47431,16 +47440,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliNullable", + OperationName: "TestRequestRequiredStringUnixMicroNullable", OperationSummary: "", - OperationID: "test_request_required_string_unix-milli_nullable", + OperationID: "test_request_required_string_unix-micro_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUnixMilli + Request = NilStringUnixMicro Params = struct{} Response = *Error ) @@ -47453,12 +47462,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -47466,7 +47475,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 return } - if err := encodeTestRequestRequiredStringUnixMilliNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47475,18 +47484,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0 } } -// handleTestRequestRequiredStringUnixMilliNullableArrayRequest handles test_request_required_string_unix-milli_nullable_array operation. +// handleTestRequestRequiredStringUnixMicroNullableArrayRequest handles test_request_required_string_unix-micro_nullable_array operation. // -// POST /test_request_required_string_unix-milli_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayRequest(args [0]string, argsEscaped bool, 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_unix-micro_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47511,11 +47520,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliNullableArray", - ID: "test_request_required_string_unix-milli_nullable_array", + Name: "TestRequestRequiredStringUnixMicroNullableArray", + ID: "test_request_required_string_unix-micro_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47535,16 +47544,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliNullableArray", + OperationName: "TestRequestRequiredStringUnixMicroNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-milli_nullable_array", + OperationID: "test_request_required_string_unix-micro_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixMilli + Request = []NilStringUnixMicro Params = struct{} Response = *Error ) @@ -47557,12 +47566,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -47570,7 +47579,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUnixMilliNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47579,18 +47588,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(ar } } -// handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest handles test_request_required_string_unix-milli_nullable_array_array operation. +// handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest handles test_request_required_string_unix-micro_nullable_array_array operation. // -// POST /test_request_required_string_unix-milli_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-micro_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix-micro_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-micro_nullable_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(), "TestRequestRequiredStringUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47615,11 +47624,11 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixMilliNullableArrayArray", - ID: "test_request_required_string_unix-milli_nullable_array_array", + Name: "TestRequestRequiredStringUnixMicroNullableArrayArray", + ID: "test_request_required_string_unix-micro_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMicroNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47639,16 +47648,16 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixMilliNullableArrayArray", + OperationName: "TestRequestRequiredStringUnixMicroNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-milli_nullable_array_array", + OperationID: "test_request_required_string_unix-micro_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixMilli + Request = [][]NilStringUnixMicro Params = struct{} Response = *Error ) @@ -47661,12 +47670,12 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMicroNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -47674,7 +47683,7 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque return } - if err := encodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47683,18 +47692,18 @@ func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayReque } } -// handleTestRequestRequiredStringUnixNanoRequest handles test_request_required_string_unix-nano operation. +// handleTestRequestRequiredStringUnixMilliRequest handles test_request_required_string_unix-milli operation. // -// POST /test_request_required_string_unix-nano -func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli +func (s *Server) handleTestRequestRequiredStringUnixMilliRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano"), + otelogen.OperationID("test_request_required_string_unix-milli"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNano", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilli", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47719,11 +47728,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNano", - ID: "test_request_required_string_unix-nano", + Name: "TestRequestRequiredStringUnixMilli", + ID: "test_request_required_string_unix-milli", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47743,9 +47752,9 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNano", + OperationName: "TestRequestRequiredStringUnixMilli", OperationSummary: "", - OperationID: "test_request_required_string_unix-nano", + OperationID: "test_request_required_string_unix-milli", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -47765,12 +47774,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNano(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilli(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNano(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilli(ctx, request) } if err != nil { recordError("Internal", err) @@ -47778,7 +47787,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, return } - if err := encodeTestRequestRequiredStringUnixNanoResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47787,18 +47796,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, } } -// handleTestRequestRequiredStringUnixNanoArrayRequest handles test_request_required_string_unix-nano_array operation. +// handleTestRequestRequiredStringUnixMilliArrayRequest handles test_request_required_string_unix-milli_array operation. // -// POST /test_request_required_string_unix-nano_array -func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_array +func (s *Server) handleTestRequestRequiredStringUnixMilliArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_array"), + otelogen.OperationID("test_request_required_string_unix-milli_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47823,11 +47832,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoArray", - ID: "test_request_required_string_unix-nano_array", + Name: "TestRequestRequiredStringUnixMilliArray", + ID: "test_request_required_string_unix-milli_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47847,9 +47856,9 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoArray", + OperationName: "TestRequestRequiredStringUnixMilliArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-nano_array", + OperationID: "test_request_required_string_unix-milli_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -47869,12 +47878,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -47882,7 +47891,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str return } - if err := encodeTestRequestRequiredStringUnixNanoArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47891,18 +47900,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]str } } -// handleTestRequestRequiredStringUnixNanoArrayArrayRequest handles test_request_required_string_unix-nano_array_array operation. +// handleTestRequestRequiredStringUnixMilliArrayArrayRequest handles test_request_required_string_unix-milli_array_array operation. // -// POST /test_request_required_string_unix-nano_array_array -func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_array_array +func (s *Server) handleTestRequestRequiredStringUnixMilliArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix-milli_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_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(), "TestRequestRequiredStringUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -47927,11 +47936,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoArrayArray", - ID: "test_request_required_string_unix-nano_array_array", + Name: "TestRequestRequiredStringUnixMilliArrayArray", + ID: "test_request_required_string_unix-milli_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -47951,9 +47960,9 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoArrayArray", + OperationName: "TestRequestRequiredStringUnixMilliArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-nano_array_array", + OperationID: "test_request_required_string_unix-milli_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -47973,12 +47982,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -47986,7 +47995,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ return } - if err := encodeTestRequestRequiredStringUnixNanoArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -47995,18 +48004,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [ } } -// handleTestRequestRequiredStringUnixNanoNullableRequest handles test_request_required_string_unix-nano_nullable operation. +// handleTestRequestRequiredStringUnixMilliNullableRequest handles test_request_required_string_unix-milli_nullable operation. // -// POST /test_request_required_string_unix-nano_nullable -func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_nullable +func (s *Server) handleTestRequestRequiredStringUnixMilliNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-nano_nullable"), + otelogen.OperationID("test_request_required_string_unix-milli_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixMilliNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48031,11 +48040,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoNullable", - ID: "test_request_required_string_unix-nano_nullable", + Name: "TestRequestRequiredStringUnixMilliNullable", + ID: "test_request_required_string_unix-milli_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48055,16 +48064,16 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoNullable", + OperationName: "TestRequestRequiredStringUnixMilliNullable", OperationSummary: "", - OperationID: "test_request_required_string_unix-nano_nullable", + OperationID: "test_request_required_string_unix-milli_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUnixNano + Request = NilStringUnixMilli Params = struct{} Response = *Error ) @@ -48077,12 +48086,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -48090,7 +48099,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] return } - if err := encodeTestRequestRequiredStringUnixNanoNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48099,18 +48108,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0] } } -// handleTestRequestRequiredStringUnixNanoNullableArrayRequest handles test_request_required_string_unix-nano_nullable_array operation. +// handleTestRequestRequiredStringUnixMilliNullableArrayRequest handles test_request_required_string_unix-milli_nullable_array operation. // -// POST /test_request_required_string_unix-nano_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayRequest(args [0]string, argsEscaped bool, 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_unix-milli_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_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(), "TestRequestRequiredStringUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48135,11 +48144,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoNullableArray", - ID: "test_request_required_string_unix-nano_nullable_array", + Name: "TestRequestRequiredStringUnixMilliNullableArray", + ID: "test_request_required_string_unix-milli_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48159,16 +48168,16 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoNullableArray", + OperationName: "TestRequestRequiredStringUnixMilliNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-nano_nullable_array", + OperationID: "test_request_required_string_unix-milli_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixNano + Request = []NilStringUnixMilli Params = struct{} Response = *Error ) @@ -48181,12 +48190,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -48194,7 +48203,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg return } - if err := encodeTestRequestRequiredStringUnixNanoNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48203,18 +48212,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(arg } } -// handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest handles test_request_required_string_unix-nano_nullable_array_array operation. +// handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest handles test_request_required_string_unix-milli_nullable_array_array operation. // -// POST /test_request_required_string_unix-nano_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-milli_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix-milli_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-milli_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(), "TestRequestRequiredStringUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48239,11 +48248,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNanoNullableArrayArray", - ID: "test_request_required_string_unix-nano_nullable_array_array", + Name: "TestRequestRequiredStringUnixMilliNullableArrayArray", + ID: "test_request_required_string_unix-milli_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixMilliNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48263,16 +48272,16 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNanoNullableArrayArray", + OperationName: "TestRequestRequiredStringUnixMilliNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-nano_nullable_array_array", + OperationID: "test_request_required_string_unix-milli_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixNano + Request = [][]NilStringUnixMilli Params = struct{} Response = *Error ) @@ -48285,12 +48294,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixMilliNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -48298,7 +48307,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques return } - if err := encodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48307,18 +48316,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayReques } } -// handleTestRequestRequiredStringUnixNullableRequest handles test_request_required_string_unix_nullable operation. +// handleTestRequestRequiredStringUnixNanoRequest handles test_request_required_string_unix-nano operation. // -// POST /test_request_required_string_unix_nullable -func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano +func (s *Server) handleTestRequestRequiredStringUnixNanoRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable"), + otelogen.OperationID("test_request_required_string_unix-nano"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNano", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48343,11 +48352,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNullable", - ID: "test_request_required_string_unix_nullable", + Name: "TestRequestRequiredStringUnixNano", + ID: "test_request_required_string_unix-nano", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48367,16 +48376,16 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNullable", + OperationName: "TestRequestRequiredStringUnixNano", OperationSummary: "", - OperationID: "test_request_required_string_unix_nullable", + OperationID: "test_request_required_string_unix-nano", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = NilStringUnixSeconds + Request = time.Time Params = struct{} Response = *Error ) @@ -48389,12 +48398,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNano(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNano(ctx, request) } if err != nil { recordError("Internal", err) @@ -48402,7 +48411,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri return } - if err := encodeTestRequestRequiredStringUnixNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48411,18 +48420,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]stri } } -// handleTestRequestRequiredStringUnixNullableArrayRequest handles test_request_required_string_unix_nullable_array operation. +// handleTestRequestRequiredStringUnixNanoArrayRequest handles test_request_required_string_unix-nano_array operation. // -// POST /test_request_required_string_unix_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_array +func (s *Server) handleTestRequestRequiredStringUnixNanoArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix_nullable_array"), + otelogen.OperationID("test_request_required_string_unix-nano_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48447,11 +48456,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNullableArray", - ID: "test_request_required_string_unix_nullable_array", + Name: "TestRequestRequiredStringUnixNanoArray", + ID: "test_request_required_string_unix-nano_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48471,16 +48480,16 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNullableArray", + OperationName: "TestRequestRequiredStringUnixNanoArray", OperationSummary: "", - OperationID: "test_request_required_string_unix_nullable_array", + OperationID: "test_request_required_string_unix-nano_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixSeconds + Request = []time.Time Params = struct{} Response = *Error ) @@ -48493,12 +48502,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -48506,7 +48515,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 return } - if err := encodeTestRequestRequiredStringUnixNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48515,18 +48524,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0 } } -// handleTestRequestRequiredStringUnixNullableArrayArrayRequest handles test_request_required_string_unix_nullable_array_array operation. +// handleTestRequestRequiredStringUnixNanoArrayArrayRequest handles test_request_required_string_unix-nano_array_array operation. // -// POST /test_request_required_string_unix_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_array_array +func (s *Server) handleTestRequestRequiredStringUnixNanoArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix-nano_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_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(), "TestRequestRequiredStringUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48551,11 +48560,11 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixNullableArrayArray", - ID: "test_request_required_string_unix_nullable_array_array", + Name: "TestRequestRequiredStringUnixNanoArrayArray", + ID: "test_request_required_string_unix-nano_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48575,16 +48584,16 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixNullableArrayArray", + OperationName: "TestRequestRequiredStringUnixNanoArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix_nullable_array_array", + OperationID: "test_request_required_string_unix-nano_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixSeconds + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -48597,12 +48606,12 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -48610,7 +48619,7 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar return } - if err := encodeTestRequestRequiredStringUnixNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48619,18 +48628,18 @@ func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(ar } } -// handleTestRequestRequiredStringUnixSecondsRequest handles test_request_required_string_unix-seconds operation. +// handleTestRequestRequiredStringUnixNanoNullableRequest handles test_request_required_string_unix-nano_nullable operation. // -// POST /test_request_required_string_unix-seconds -func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_nullable +func (s *Server) handleTestRequestRequiredStringUnixNanoNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSeconds", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNanoNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48655,11 +48664,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSeconds", - ID: "test_request_required_string_unix-seconds", + Name: "TestRequestRequiredStringUnixNanoNullable", + ID: "test_request_required_string_unix-nano_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48679,16 +48688,16 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSeconds", + OperationName: "TestRequestRequiredStringUnixNanoNullable", OperationSummary: "", - OperationID: "test_request_required_string_unix-seconds", + OperationID: "test_request_required_string_unix-nano_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = time.Time + Request = NilStringUnixNano Params = struct{} Response = *Error ) @@ -48701,12 +48710,12 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixSeconds(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSeconds(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -48714,7 +48723,7 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin return } - if err := encodeTestRequestRequiredStringUnixSecondsResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48723,18 +48732,18 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]strin } } -// handleTestRequestRequiredStringUnixSecondsArrayRequest handles test_request_required_string_unix-seconds_array operation. +// handleTestRequestRequiredStringUnixNanoNullableArrayRequest handles test_request_required_string_unix-nano_nullable_array operation. // -// POST /test_request_required_string_unix-seconds_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_array"), + otelogen.OperationID("test_request_required_string_unix-nano_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_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(), "TestRequestRequiredStringUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48759,11 +48768,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsArray", - ID: "test_request_required_string_unix-seconds_array", + Name: "TestRequestRequiredStringUnixNanoNullableArray", + ID: "test_request_required_string_unix-nano_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48783,16 +48792,16 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsArray", + OperationName: "TestRequestRequiredStringUnixNanoNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-seconds_array", + OperationID: "test_request_required_string_unix-nano_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = []NilStringUnixNano Params = struct{} Response = *Error ) @@ -48805,12 +48814,12 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -48818,7 +48827,7 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] return } - if err := encodeTestRequestRequiredStringUnixSecondsArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48827,18 +48836,18 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0] } } -// handleTestRequestRequiredStringUnixSecondsArrayArrayRequest handles test_request_required_string_unix-seconds_array_array operation. +// handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest handles test_request_required_string_unix-nano_nullable_array_array operation. // -// POST /test_request_required_string_unix-seconds_array_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-nano_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix-nano_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-nano_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(), "TestRequestRequiredStringUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48863,11 +48872,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsArrayArray", - ID: "test_request_required_string_unix-seconds_array_array", + Name: "TestRequestRequiredStringUnixNanoNullableArrayArray", + ID: "test_request_required_string_unix-nano_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNanoNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48887,16 +48896,16 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsArrayArray", + OperationName: "TestRequestRequiredStringUnixNanoNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-seconds_array_array", + OperationID: "test_request_required_string_unix-nano_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilStringUnixNano Params = struct{} Response = *Error ) @@ -48909,12 +48918,12 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNanoNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -48922,7 +48931,7 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg return } - if err := encodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -48931,18 +48940,18 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(arg } } -// handleTestRequestRequiredStringUnixSecondsNullableRequest handles test_request_required_string_unix-seconds_nullable operation. +// handleTestRequestRequiredStringUnixNullableRequest handles test_request_required_string_unix_nullable operation. // -// POST /test_request_required_string_unix-seconds_nullable -func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_nullable +func (s *Server) handleTestRequestRequiredStringUnixNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_required_string_unix-seconds_nullable"), + otelogen.OperationID("test_request_required_string_unix_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_nullable"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -48967,11 +48976,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsNullable", - ID: "test_request_required_string_unix-seconds_nullable", + Name: "TestRequestRequiredStringUnixNullable", + ID: "test_request_required_string_unix_nullable", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -48991,9 +49000,9 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsNullable", + OperationName: "TestRequestRequiredStringUnixNullable", OperationSummary: "", - OperationID: "test_request_required_string_unix-seconds_nullable", + OperationID: "test_request_required_string_unix_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -49013,12 +49022,12 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -49026,7 +49035,7 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args return } - if err := encodeTestRequestRequiredStringUnixSecondsNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49035,18 +49044,18 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args } } -// handleTestRequestRequiredStringUnixSecondsNullableArrayRequest handles test_request_required_string_unix-seconds_nullable_array operation. +// handleTestRequestRequiredStringUnixNullableArrayRequest handles test_request_required_string_unix_nullable_array operation. // -// POST /test_request_required_string_unix-seconds_nullable_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixNullableArrayRequest(args [0]string, argsEscaped bool, 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_unix_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49071,11 +49080,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsNullableArray", - ID: "test_request_required_string_unix-seconds_nullable_array", + Name: "TestRequestRequiredStringUnixNullableArray", + ID: "test_request_required_string_unix_nullable_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49095,9 +49104,9 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsNullableArray", + OperationName: "TestRequestRequiredStringUnixNullableArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-seconds_nullable_array", + OperationID: "test_request_required_string_unix_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -49117,12 +49126,12 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -49130,7 +49139,7 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( return } - if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49139,18 +49148,18 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest( } } -// handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest handles test_request_required_string_unix-seconds_nullable_array_array operation. +// handleTestRequestRequiredStringUnixNullableArrayArrayRequest handles test_request_required_string_unix_nullable_array_array operation. // -// POST /test_request_required_string_unix-seconds_nullable_array_array -func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixNullableArrayArrayRequest(args [0]string, argsEscaped bool, 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_unix_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix_nullable_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(), "TestRequestRequiredStringUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49175,11 +49184,11 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestRequiredStringUnixSecondsNullableArrayArray", - ID: "test_request_required_string_unix-seconds_nullable_array_array", + Name: "TestRequestRequiredStringUnixNullableArrayArray", + ID: "test_request_required_string_unix_nullable_array_array", } ) - request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49199,9 +49208,9 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestRequiredStringUnixSecondsNullableArrayArray", + OperationName: "TestRequestRequiredStringUnixNullableArrayArray", OperationSummary: "", - OperationID: "test_request_required_string_unix-seconds_nullable_array_array", + OperationID: "test_request_required_string_unix_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -49221,12 +49230,12 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -49234,7 +49243,7 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq return } - if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49243,18 +49252,18 @@ func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayReq } } -// handleTestRequestStringRequest handles test_request_string operation. +// handleTestRequestRequiredStringUnixSecondsRequest handles test_request_required_string_unix-seconds operation. // -// POST /test_request_string -func (s *Server) handleTestRequestStringRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds +func (s *Server) handleTestRequestRequiredStringUnixSecondsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string"), + otelogen.OperationID("test_request_required_string_unix-seconds"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestString", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSeconds", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49279,11 +49288,11 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, argsEscaped bool } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestString", - ID: "test_request_string", + Name: "TestRequestRequiredStringUnixSeconds", + ID: "test_request_required_string_unix-seconds", } ) - request, close, err := s.decodeTestRequestStringRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49303,16 +49312,16 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, argsEscaped bool if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestString", + OperationName: "TestRequestRequiredStringUnixSeconds", OperationSummary: "", - OperationID: "test_request_string", + OperationID: "test_request_required_string_unix-seconds", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptString + Request = time.Time Params = struct{} Response = *Error ) @@ -49325,12 +49334,12 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, argsEscaped bool mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestString(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSeconds(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestString(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSeconds(ctx, request) } if err != nil { recordError("Internal", err) @@ -49338,7 +49347,7 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, argsEscaped bool return } - if err := encodeTestRequestStringResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49347,18 +49356,18 @@ func (s *Server) handleTestRequestStringRequest(args [0]string, argsEscaped bool } } -// handleTestRequestStringArrayRequest handles test_request_string_array operation. +// handleTestRequestRequiredStringUnixSecondsArrayRequest handles test_request_required_string_unix-seconds_array operation. // -// POST /test_request_string_array -func (s *Server) handleTestRequestStringArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49383,11 +49392,11 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringArray", - ID: "test_request_string_array", + Name: "TestRequestRequiredStringUnixSecondsArray", + ID: "test_request_required_string_unix-seconds_array", } ) - request, close, err := s.decodeTestRequestStringArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49407,16 +49416,16 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringArray", + OperationName: "TestRequestRequiredStringUnixSecondsArray", OperationSummary: "", - OperationID: "test_request_string_array", + OperationID: "test_request_required_string_unix-seconds_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []string + Request = []time.Time Params = struct{} Response = *Error ) @@ -49429,12 +49438,12 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -49442,7 +49451,7 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49451,18 +49460,18 @@ func (s *Server) handleTestRequestStringArrayRequest(args [0]string, argsEscaped } } -// handleTestRequestStringArrayArrayRequest handles test_request_string_array_array operation. +// handleTestRequestRequiredStringUnixSecondsArrayArrayRequest handles test_request_required_string_unix-seconds_array_array operation. // -// POST /test_request_string_array_array -func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_array_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_array_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_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(), "TestRequestRequiredStringUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49487,11 +49496,11 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringArrayArray", - ID: "test_request_string_array_array", + Name: "TestRequestRequiredStringUnixSecondsArrayArray", + ID: "test_request_required_string_unix-seconds_array_array", } ) - request, close, err := s.decodeTestRequestStringArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49511,16 +49520,16 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringArrayArray", + OperationName: "TestRequestRequiredStringUnixSecondsArrayArray", OperationSummary: "", - OperationID: "test_request_string_array_array", + OperationID: "test_request_required_string_unix-seconds_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]string + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -49533,12 +49542,12 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -49546,7 +49555,7 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, argsEs return } - if err := encodeTestRequestStringArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49555,18 +49564,18 @@ func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, argsEs } } -// handleTestRequestStringBase64Request handles test_request_string_base64 operation. +// handleTestRequestRequiredStringUnixSecondsNullableRequest handles test_request_required_string_unix-seconds_nullable operation. // -// POST /test_request_string_base64 -func (s *Server) handleTestRequestStringBase64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_nullable +func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_base64"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_base64"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49591,11 +49600,11 @@ func (s *Server) handleTestRequestStringBase64Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBase64", - ID: "test_request_string_base64", + Name: "TestRequestRequiredStringUnixSecondsNullable", + ID: "test_request_required_string_unix-seconds_nullable", } ) - request, close, err := s.decodeTestRequestStringBase64Request(r) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49615,16 +49624,16 @@ func (s *Server) handleTestRequestStringBase64Request(args [0]string, argsEscape if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBase64", + OperationName: "TestRequestRequiredStringUnixSecondsNullable", OperationSummary: "", - OperationID: "test_request_string_base64", + OperationID: "test_request_required_string_unix-seconds_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []byte + Request = NilStringUnixSeconds Params = struct{} Response = *Error ) @@ -49637,12 +49646,12 @@ func (s *Server) handleTestRequestStringBase64Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBase64(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBase64(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -49650,7 +49659,7 @@ func (s *Server) handleTestRequestStringBase64Request(args [0]string, argsEscape return } - if err := encodeTestRequestStringBase64Response(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49659,18 +49668,18 @@ func (s *Server) handleTestRequestStringBase64Request(args [0]string, argsEscape } } -// handleTestRequestStringBase64ArrayRequest handles test_request_string_base64_array operation. +// handleTestRequestRequiredStringUnixSecondsNullableArrayRequest handles test_request_required_string_unix-seconds_nullable_array operation. // -// POST /test_request_string_base64_array -func (s *Server) handleTestRequestStringBase64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_nullable_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_base64_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_base64_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49695,11 +49704,11 @@ func (s *Server) handleTestRequestStringBase64ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBase64Array", - ID: "test_request_string_base64_array", + Name: "TestRequestRequiredStringUnixSecondsNullableArray", + ID: "test_request_required_string_unix-seconds_nullable_array", } ) - request, close, err := s.decodeTestRequestStringBase64ArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49719,16 +49728,16 @@ func (s *Server) handleTestRequestStringBase64ArrayRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBase64Array", + OperationName: "TestRequestRequiredStringUnixSecondsNullableArray", OperationSummary: "", - OperationID: "test_request_string_base64_array", + OperationID: "test_request_required_string_unix-seconds_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]byte + Request = []NilStringUnixSeconds Params = struct{} Response = *Error ) @@ -49741,12 +49750,12 @@ func (s *Server) handleTestRequestStringBase64ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBase64Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBase64Array(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -49754,7 +49763,7 @@ func (s *Server) handleTestRequestStringBase64ArrayRequest(args [0]string, argsE return } - if err := encodeTestRequestStringBase64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49763,18 +49772,18 @@ func (s *Server) handleTestRequestStringBase64ArrayRequest(args [0]string, argsE } } -// handleTestRequestStringBase64ArrayArrayRequest handles test_request_string_base64_array_array operation. +// handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest handles test_request_required_string_unix-seconds_nullable_array_array operation. // -// POST /test_request_string_base64_array_array -func (s *Server) handleTestRequestStringBase64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_required_string_unix-seconds_nullable_array_array +func (s *Server) handleTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_base64_array_array"), + otelogen.OperationID("test_request_required_string_unix-seconds_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_base64_array_array"), + semconv.HTTPRouteKey.String("/test_request_required_string_unix-seconds_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestRequiredStringUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49799,11 +49808,11 @@ func (s *Server) handleTestRequestStringBase64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBase64ArrayArray", - ID: "test_request_string_base64_array_array", + Name: "TestRequestRequiredStringUnixSecondsNullableArrayArray", + ID: "test_request_required_string_unix-seconds_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringBase64ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49823,16 +49832,16 @@ func (s *Server) handleTestRequestStringBase64ArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBase64ArrayArray", + OperationName: "TestRequestRequiredStringUnixSecondsNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_base64_array_array", + OperationID: "test_request_required_string_unix-seconds_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]NilStringUnixSeconds Params = struct{} Response = *Error ) @@ -49845,12 +49854,12 @@ func (s *Server) handleTestRequestStringBase64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBase64ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBase64ArrayArray(ctx, request) + response, err = s.h.TestRequestRequiredStringUnixSecondsNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -49858,7 +49867,7 @@ func (s *Server) handleTestRequestStringBase64ArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringBase64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49867,18 +49876,18 @@ func (s *Server) handleTestRequestStringBase64ArrayArrayRequest(args [0]string, } } -// handleTestRequestStringBase64NullableRequest handles test_request_string_base64_nullable operation. +// handleTestRequestStringRequest handles test_request_string operation. // -// POST /test_request_string_base64_nullable -func (s *Server) handleTestRequestStringBase64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string +func (s *Server) handleTestRequestStringRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_base64_nullable"), + otelogen.OperationID("test_request_string"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_base64_nullable"), + semconv.HTTPRouteKey.String("/test_request_string"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestString", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -49903,11 +49912,11 @@ func (s *Server) handleTestRequestStringBase64NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBase64Nullable", - ID: "test_request_string_base64_nullable", + Name: "TestRequestString", + ID: "test_request_string", } ) - request, close, err := s.decodeTestRequestStringBase64NullableRequest(r) + request, close, err := s.decodeTestRequestStringRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -49927,16 +49936,16 @@ func (s *Server) handleTestRequestStringBase64NullableRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBase64Nullable", + OperationName: "TestRequestString", OperationSummary: "", - OperationID: "test_request_string_base64_nullable", + OperationID: "test_request_string", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilByte + Request = OptString Params = struct{} Response = *Error ) @@ -49949,12 +49958,12 @@ func (s *Server) handleTestRequestStringBase64NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBase64Nullable(ctx, request) + response, err = s.h.TestRequestString(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBase64Nullable(ctx, request) + response, err = s.h.TestRequestString(ctx, request) } if err != nil { recordError("Internal", err) @@ -49962,7 +49971,7 @@ func (s *Server) handleTestRequestStringBase64NullableRequest(args [0]string, ar return } - if err := encodeTestRequestStringBase64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -49971,18 +49980,18 @@ func (s *Server) handleTestRequestStringBase64NullableRequest(args [0]string, ar } } -// handleTestRequestStringBase64NullableArrayRequest handles test_request_string_base64_nullable_array operation. +// handleTestRequestStringArrayRequest handles test_request_string_array operation. // -// POST /test_request_string_base64_nullable_array -func (s *Server) handleTestRequestStringBase64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_array +func (s *Server) handleTestRequestStringArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_base64_nullable_array"), + otelogen.OperationID("test_request_string_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_base64_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50007,11 +50016,11 @@ func (s *Server) handleTestRequestStringBase64NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBase64NullableArray", - ID: "test_request_string_base64_nullable_array", + Name: "TestRequestStringArray", + ID: "test_request_string_array", } ) - request, close, err := s.decodeTestRequestStringBase64NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50031,16 +50040,16 @@ func (s *Server) handleTestRequestStringBase64NullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBase64NullableArray", + OperationName: "TestRequestStringArray", OperationSummary: "", - OperationID: "test_request_string_base64_nullable_array", + OperationID: "test_request_string_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]byte + Request = []string Params = struct{} Response = *Error ) @@ -50053,12 +50062,12 @@ func (s *Server) handleTestRequestStringBase64NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBase64NullableArray(ctx, request) + response, err = s.h.TestRequestStringArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBase64NullableArray(ctx, request) + response, err = s.h.TestRequestStringArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -50066,7 +50075,7 @@ func (s *Server) handleTestRequestStringBase64NullableArrayRequest(args [0]strin return } - if err := encodeTestRequestStringBase64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50075,18 +50084,18 @@ func (s *Server) handleTestRequestStringBase64NullableArrayRequest(args [0]strin } } -// handleTestRequestStringBase64NullableArrayArrayRequest handles test_request_string_base64_nullable_array_array operation. +// handleTestRequestStringArrayArrayRequest handles test_request_string_array_array operation. // -// POST /test_request_string_base64_nullable_array_array -func (s *Server) handleTestRequestStringBase64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_array_array +func (s *Server) handleTestRequestStringArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_base64_nullable_array_array"), + otelogen.OperationID("test_request_string_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_base64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50111,11 +50120,11 @@ func (s *Server) handleTestRequestStringBase64NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBase64NullableArrayArray", - ID: "test_request_string_base64_nullable_array_array", + Name: "TestRequestStringArrayArray", + ID: "test_request_string_array_array", } ) - request, close, err := s.decodeTestRequestStringBase64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50135,16 +50144,16 @@ func (s *Server) handleTestRequestStringBase64NullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBase64NullableArrayArray", + OperationName: "TestRequestStringArrayArray", OperationSummary: "", - OperationID: "test_request_string_base64_nullable_array_array", + OperationID: "test_request_string_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]string Params = struct{} Response = *Error ) @@ -50157,12 +50166,12 @@ func (s *Server) handleTestRequestStringBase64NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBase64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBase64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -50170,7 +50179,7 @@ func (s *Server) handleTestRequestStringBase64NullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestStringBase64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50179,18 +50188,18 @@ func (s *Server) handleTestRequestStringBase64NullableArrayArrayRequest(args [0] } } -// handleTestRequestStringBinaryRequest handles test_request_string_binary operation. +// handleTestRequestStringBase64Request handles test_request_string_base64 operation. // -// POST /test_request_string_binary -func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_base64 +func (s *Server) handleTestRequestStringBase64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary"), + otelogen.OperationID("test_request_string_base64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_binary"), + semconv.HTTPRouteKey.String("/test_request_string_base64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinary", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50215,11 +50224,11 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinary", - ID: "test_request_string_binary", + Name: "TestRequestStringBase64", + ID: "test_request_string_base64", } ) - request, close, err := s.decodeTestRequestStringBinaryRequest(r) + request, close, err := s.decodeTestRequestStringBase64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50239,16 +50248,16 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, argsEscape if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinary", + OperationName: "TestRequestStringBase64", OperationSummary: "", - OperationID: "test_request_string_binary", + OperationID: "test_request_string_base64", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptString + Request = []byte Params = struct{} Response = *Error ) @@ -50261,12 +50270,12 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBinary(ctx, request) + response, err = s.h.TestRequestStringBase64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBinary(ctx, request) + response, err = s.h.TestRequestStringBase64(ctx, request) } if err != nil { recordError("Internal", err) @@ -50274,7 +50283,7 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, argsEscape return } - if err := encodeTestRequestStringBinaryResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBase64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50283,18 +50292,18 @@ func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, argsEscape } } -// handleTestRequestStringBinaryArrayRequest handles test_request_string_binary_array operation. +// handleTestRequestStringBase64ArrayRequest handles test_request_string_base64_array operation. // -// POST /test_request_string_binary_array -func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_base64_array +func (s *Server) handleTestRequestStringBase64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_array"), + otelogen.OperationID("test_request_string_base64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_binary_array"), + semconv.HTTPRouteKey.String("/test_request_string_base64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50319,11 +50328,11 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryArray", - ID: "test_request_string_binary_array", + Name: "TestRequestStringBase64Array", + ID: "test_request_string_base64_array", } ) - request, close, err := s.decodeTestRequestStringBinaryArrayRequest(r) + request, close, err := s.decodeTestRequestStringBase64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50343,16 +50352,16 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryArray", + OperationName: "TestRequestStringBase64Array", OperationSummary: "", - OperationID: "test_request_string_binary_array", + OperationID: "test_request_string_base64_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []string + Request = [][]byte Params = struct{} Response = *Error ) @@ -50365,12 +50374,12 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBinaryArray(ctx, request) + response, err = s.h.TestRequestStringBase64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBinaryArray(ctx, request) + response, err = s.h.TestRequestStringBase64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -50378,7 +50387,7 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, argsE return } - if err := encodeTestRequestStringBinaryArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBase64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50387,18 +50396,18 @@ func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, argsE } } -// handleTestRequestStringBinaryArrayArrayRequest handles test_request_string_binary_array_array operation. +// handleTestRequestStringBase64ArrayArrayRequest handles test_request_string_base64_array_array operation. // -// POST /test_request_string_binary_array_array -func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_base64_array_array +func (s *Server) handleTestRequestStringBase64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_array_array"), + otelogen.OperationID("test_request_string_base64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_binary_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_base64_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(), "TestRequestStringBase64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50423,11 +50432,11 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryArrayArray", - ID: "test_request_string_binary_array_array", + Name: "TestRequestStringBase64ArrayArray", + ID: "test_request_string_base64_array_array", } ) - request, close, err := s.decodeTestRequestStringBinaryArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringBase64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50447,16 +50456,16 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryArrayArray", + OperationName: "TestRequestStringBase64ArrayArray", OperationSummary: "", - OperationID: "test_request_string_binary_array_array", + OperationID: "test_request_string_base64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]string + Request = [][][]byte Params = struct{} Response = *Error ) @@ -50469,12 +50478,12 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBinaryArrayArray(ctx, request) + response, err = s.h.TestRequestStringBase64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBinaryArrayArray(ctx, request) + response, err = s.h.TestRequestStringBase64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -50482,7 +50491,7 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringBinaryArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBase64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50491,18 +50500,18 @@ func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, } } -// handleTestRequestStringBinaryNullableRequest handles test_request_string_binary_nullable operation. +// handleTestRequestStringBase64NullableRequest handles test_request_string_base64_nullable operation. // -// POST /test_request_string_binary_nullable -func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_base64_nullable +func (s *Server) handleTestRequestStringBase64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable"), + otelogen.OperationID("test_request_string_base64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_binary_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_base64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBase64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50527,11 +50536,11 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryNullable", - ID: "test_request_string_binary_nullable", + Name: "TestRequestStringBase64Nullable", + ID: "test_request_string_base64_nullable", } ) - request, close, err := s.decodeTestRequestStringBinaryNullableRequest(r) + request, close, err := s.decodeTestRequestStringBase64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50551,16 +50560,16 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryNullable", + OperationName: "TestRequestStringBase64Nullable", OperationSummary: "", - OperationID: "test_request_string_binary_nullable", + OperationID: "test_request_string_base64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilString + Request = OptNilByte Params = struct{} Response = *Error ) @@ -50573,12 +50582,12 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBinaryNullable(ctx, request) + response, err = s.h.TestRequestStringBase64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBinaryNullable(ctx, request) + response, err = s.h.TestRequestStringBase64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -50586,7 +50595,7 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, ar return } - if err := encodeTestRequestStringBinaryNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBase64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50595,18 +50604,18 @@ func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, ar } } -// handleTestRequestStringBinaryNullableArrayRequest handles test_request_string_binary_nullable_array operation. +// handleTestRequestStringBase64NullableArrayRequest handles test_request_string_base64_nullable_array operation. // -// POST /test_request_string_binary_nullable_array -func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_base64_nullable_array +func (s *Server) handleTestRequestStringBase64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable_array"), + otelogen.OperationID("test_request_string_base64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_binary_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_base64_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(), "TestRequestStringBase64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50631,11 +50640,11 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryNullableArray", - ID: "test_request_string_binary_nullable_array", + Name: "TestRequestStringBase64NullableArray", + ID: "test_request_string_base64_nullable_array", } ) - request, close, err := s.decodeTestRequestStringBinaryNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringBase64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50655,16 +50664,16 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryNullableArray", + OperationName: "TestRequestStringBase64NullableArray", OperationSummary: "", - OperationID: "test_request_string_binary_nullable_array", + OperationID: "test_request_string_base64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilString + Request = [][]byte Params = struct{} Response = *Error ) @@ -50677,12 +50686,12 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBinaryNullableArray(ctx, request) + response, err = s.h.TestRequestStringBase64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBinaryNullableArray(ctx, request) + response, err = s.h.TestRequestStringBase64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -50690,7 +50699,7 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin return } - if err := encodeTestRequestStringBinaryNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBase64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50699,18 +50708,18 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]strin } } -// handleTestRequestStringBinaryNullableArrayArrayRequest handles test_request_string_binary_nullable_array_array operation. +// handleTestRequestStringBase64NullableArrayArrayRequest handles test_request_string_base64_nullable_array_array operation. // -// POST /test_request_string_binary_nullable_array_array -func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_base64_nullable_array_array +func (s *Server) handleTestRequestStringBase64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_binary_nullable_array_array"), + otelogen.OperationID("test_request_string_base64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_binary_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_base64_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(), "TestRequestStringBase64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50735,11 +50744,11 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringBinaryNullableArrayArray", - ID: "test_request_string_binary_nullable_array_array", + Name: "TestRequestStringBase64NullableArrayArray", + ID: "test_request_string_base64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringBinaryNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringBase64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50759,16 +50768,16 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringBinaryNullableArrayArray", + OperationName: "TestRequestStringBase64NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_binary_nullable_array_array", + OperationID: "test_request_string_base64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilString + Request = [][][]byte Params = struct{} Response = *Error ) @@ -50781,12 +50790,12 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringBase64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringBase64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -50794,7 +50803,7 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBase64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50803,18 +50812,18 @@ func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0] } } -// handleTestRequestStringByteRequest handles test_request_string_byte operation. +// handleTestRequestStringBinaryRequest handles test_request_string_binary operation. // -// POST /test_request_string_byte -func (s *Server) handleTestRequestStringByteRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary +func (s *Server) handleTestRequestStringBinaryRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte"), + otelogen.OperationID("test_request_string_binary"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_byte"), + semconv.HTTPRouteKey.String("/test_request_string_binary"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByte", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinary", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50839,11 +50848,11 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByte", - ID: "test_request_string_byte", + Name: "TestRequestStringBinary", + ID: "test_request_string_binary", } ) - request, close, err := s.decodeTestRequestStringByteRequest(r) + request, close, err := s.decodeTestRequestStringBinaryRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50863,16 +50872,16 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByte", + OperationName: "TestRequestStringBinary", OperationSummary: "", - OperationID: "test_request_string_byte", + OperationID: "test_request_string_binary", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []byte + Request = OptString Params = struct{} Response = *Error ) @@ -50885,12 +50894,12 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringByte(ctx, request) + response, err = s.h.TestRequestStringBinary(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringByte(ctx, request) + response, err = s.h.TestRequestStringBinary(ctx, request) } if err != nil { recordError("Internal", err) @@ -50898,7 +50907,7 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringByteResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -50907,18 +50916,18 @@ func (s *Server) handleTestRequestStringByteRequest(args [0]string, argsEscaped } } -// handleTestRequestStringByteArrayRequest handles test_request_string_byte_array operation. +// handleTestRequestStringBinaryArrayRequest handles test_request_string_binary_array operation. // -// POST /test_request_string_byte_array -func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_array +func (s *Server) handleTestRequestStringBinaryArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_array"), + otelogen.OperationID("test_request_string_binary_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_byte_array"), + semconv.HTTPRouteKey.String("/test_request_string_binary_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -50943,11 +50952,11 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteArray", - ID: "test_request_string_byte_array", + Name: "TestRequestStringBinaryArray", + ID: "test_request_string_binary_array", } ) - request, close, err := s.decodeTestRequestStringByteArrayRequest(r) + request, close, err := s.decodeTestRequestStringBinaryArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -50967,16 +50976,16 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteArray", + OperationName: "TestRequestStringBinaryArray", OperationSummary: "", - OperationID: "test_request_string_byte_array", + OperationID: "test_request_string_binary_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]byte + Request = []string Params = struct{} Response = *Error ) @@ -50989,12 +50998,12 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringByteArray(ctx, request) + response, err = s.h.TestRequestStringBinaryArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringByteArray(ctx, request) + response, err = s.h.TestRequestStringBinaryArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -51002,7 +51011,7 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringByteArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51011,18 +51020,18 @@ func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringByteArrayArrayRequest handles test_request_string_byte_array_array operation. +// handleTestRequestStringBinaryArrayArrayRequest handles test_request_string_binary_array_array operation. // -// POST /test_request_string_byte_array_array -func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_array_array +func (s *Server) handleTestRequestStringBinaryArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_array_array"), + otelogen.OperationID("test_request_string_binary_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_byte_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_binary_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(), "TestRequestStringBinaryArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51047,11 +51056,11 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteArrayArray", - ID: "test_request_string_byte_array_array", + Name: "TestRequestStringBinaryArrayArray", + ID: "test_request_string_binary_array_array", } ) - request, close, err := s.decodeTestRequestStringByteArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringBinaryArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51071,16 +51080,16 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteArrayArray", + OperationName: "TestRequestStringBinaryArrayArray", OperationSummary: "", - OperationID: "test_request_string_byte_array_array", + OperationID: "test_request_string_binary_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]string Params = struct{} Response = *Error ) @@ -51093,12 +51102,12 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringByteArrayArray(ctx, request) + response, err = s.h.TestRequestStringBinaryArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringByteArrayArray(ctx, request) + response, err = s.h.TestRequestStringBinaryArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -51106,7 +51115,7 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringByteArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51115,18 +51124,18 @@ func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringByteNullableRequest handles test_request_string_byte_nullable operation. +// handleTestRequestStringBinaryNullableRequest handles test_request_string_binary_nullable operation. // -// POST /test_request_string_byte_nullable -func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_nullable +func (s *Server) handleTestRequestStringBinaryNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable"), + otelogen.OperationID("test_request_string_binary_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_byte_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_binary_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringBinaryNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51151,11 +51160,11 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteNullable", - ID: "test_request_string_byte_nullable", + Name: "TestRequestStringBinaryNullable", + ID: "test_request_string_binary_nullable", } ) - request, close, err := s.decodeTestRequestStringByteNullableRequest(r) + request, close, err := s.decodeTestRequestStringBinaryNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51175,16 +51184,16 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteNullable", + OperationName: "TestRequestStringBinaryNullable", OperationSummary: "", - OperationID: "test_request_string_byte_nullable", + OperationID: "test_request_string_binary_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilByte + Request = OptNilString Params = struct{} Response = *Error ) @@ -51197,12 +51206,12 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringByteNullable(ctx, request) + response, err = s.h.TestRequestStringBinaryNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringByteNullable(ctx, request) + response, err = s.h.TestRequestStringBinaryNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -51210,7 +51219,7 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, args return } - if err := encodeTestRequestStringByteNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51219,18 +51228,18 @@ func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, args } } -// handleTestRequestStringByteNullableArrayRequest handles test_request_string_byte_nullable_array operation. +// handleTestRequestStringBinaryNullableArrayRequest handles test_request_string_binary_nullable_array operation. // -// POST /test_request_string_byte_nullable_array -func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_nullable_array +func (s *Server) handleTestRequestStringBinaryNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable_array"), + otelogen.OperationID("test_request_string_binary_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_byte_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_binary_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(), "TestRequestStringBinaryNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51255,11 +51264,11 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteNullableArray", - ID: "test_request_string_byte_nullable_array", + Name: "TestRequestStringBinaryNullableArray", + ID: "test_request_string_binary_nullable_array", } ) - request, close, err := s.decodeTestRequestStringByteNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringBinaryNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51279,16 +51288,16 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteNullableArray", + OperationName: "TestRequestStringBinaryNullableArray", OperationSummary: "", - OperationID: "test_request_string_byte_nullable_array", + OperationID: "test_request_string_binary_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]byte + Request = []NilString Params = struct{} Response = *Error ) @@ -51301,12 +51310,12 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringByteNullableArray(ctx, request) + response, err = s.h.TestRequestStringBinaryNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringByteNullableArray(ctx, request) + response, err = s.h.TestRequestStringBinaryNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -51314,7 +51323,7 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringByteNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51323,18 +51332,18 @@ func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, } } -// handleTestRequestStringByteNullableArrayArrayRequest handles test_request_string_byte_nullable_array_array operation. +// handleTestRequestStringBinaryNullableArrayArrayRequest handles test_request_string_binary_nullable_array_array operation. // -// POST /test_request_string_byte_nullable_array_array -func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_binary_nullable_array_array +func (s *Server) handleTestRequestStringBinaryNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_byte_nullable_array_array"), + otelogen.OperationID("test_request_string_binary_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_byte_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_binary_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(), "TestRequestStringBinaryNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51359,11 +51368,11 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringByteNullableArrayArray", - ID: "test_request_string_byte_nullable_array_array", + Name: "TestRequestStringBinaryNullableArrayArray", + ID: "test_request_string_binary_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringByteNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringBinaryNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51383,16 +51392,16 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringByteNullableArrayArray", + OperationName: "TestRequestStringBinaryNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_byte_nullable_array_array", + OperationID: "test_request_string_binary_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][][]byte + Request = [][]NilString Params = struct{} Response = *Error ) @@ -51405,12 +51414,12 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringByteNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringByteNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringBinaryNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -51418,7 +51427,7 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringByteNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51427,18 +51436,18 @@ func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringDateRequest handles test_request_string_date operation. +// handleTestRequestStringByteRequest handles test_request_string_byte operation. // -// POST /test_request_string_date -func (s *Server) handleTestRequestStringDateRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte +func (s *Server) handleTestRequestStringByteRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date"), + otelogen.OperationID("test_request_string_byte"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date"), + semconv.HTTPRouteKey.String("/test_request_string_byte"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDate", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByte", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51463,11 +51472,11 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDate", - ID: "test_request_string_date", + Name: "TestRequestStringByte", + ID: "test_request_string_byte", } ) - request, close, err := s.decodeTestRequestStringDateRequest(r) + request, close, err := s.decodeTestRequestStringByteRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51487,16 +51496,16 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDate", + OperationName: "TestRequestStringByte", OperationSummary: "", - OperationID: "test_request_string_date", + OperationID: "test_request_string_byte", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptDate + Request = []byte Params = struct{} Response = *Error ) @@ -51509,12 +51518,12 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDate(ctx, request) + response, err = s.h.TestRequestStringByte(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDate(ctx, request) + response, err = s.h.TestRequestStringByte(ctx, request) } if err != nil { recordError("Internal", err) @@ -51522,7 +51531,7 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringDateResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51531,18 +51540,18 @@ func (s *Server) handleTestRequestStringDateRequest(args [0]string, argsEscaped } } -// handleTestRequestStringDateArrayRequest handles test_request_string_date_array operation. +// handleTestRequestStringByteArrayRequest handles test_request_string_byte_array operation. // -// POST /test_request_string_date_array -func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_array +func (s *Server) handleTestRequestStringByteArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_array"), + otelogen.OperationID("test_request_string_byte_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date_array"), + semconv.HTTPRouteKey.String("/test_request_string_byte_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51567,11 +51576,11 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateArray", - ID: "test_request_string_date_array", + Name: "TestRequestStringByteArray", + ID: "test_request_string_byte_array", } ) - request, close, err := s.decodeTestRequestStringDateArrayRequest(r) + request, close, err := s.decodeTestRequestStringByteArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51591,16 +51600,16 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateArray", + OperationName: "TestRequestStringByteArray", OperationSummary: "", - OperationID: "test_request_string_date_array", + OperationID: "test_request_string_byte_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = [][]byte Params = struct{} Response = *Error ) @@ -51613,12 +51622,12 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateArray(ctx, request) + response, err = s.h.TestRequestStringByteArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateArray(ctx, request) + response, err = s.h.TestRequestStringByteArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -51626,7 +51635,7 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringDateArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51635,18 +51644,18 @@ func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringDateArrayArrayRequest handles test_request_string_date_array_array operation. +// handleTestRequestStringByteArrayArrayRequest handles test_request_string_byte_array_array operation. // -// POST /test_request_string_date_array_array -func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_array_array +func (s *Server) handleTestRequestStringByteArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_array_array"), + otelogen.OperationID("test_request_string_byte_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_byte_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(), "TestRequestStringByteArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51671,11 +51680,11 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateArrayArray", - ID: "test_request_string_date_array_array", + Name: "TestRequestStringByteArrayArray", + ID: "test_request_string_byte_array_array", } ) - request, close, err := s.decodeTestRequestStringDateArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringByteArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51695,16 +51704,16 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateArrayArray", + OperationName: "TestRequestStringByteArrayArray", OperationSummary: "", - OperationID: "test_request_string_date_array_array", + OperationID: "test_request_string_byte_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][][]byte Params = struct{} Response = *Error ) @@ -51717,12 +51726,12 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateArrayArray(ctx, request) + response, err = s.h.TestRequestStringByteArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateArrayArray(ctx, request) + response, err = s.h.TestRequestStringByteArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -51730,7 +51739,7 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringDateArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51739,18 +51748,18 @@ func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringDateNullableRequest handles test_request_string_date_nullable operation. +// handleTestRequestStringByteNullableRequest handles test_request_string_byte_nullable operation. // -// POST /test_request_string_date_nullable -func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_nullable +func (s *Server) handleTestRequestStringByteNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable"), + otelogen.OperationID("test_request_string_byte_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_byte_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51775,11 +51784,11 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateNullable", - ID: "test_request_string_date_nullable", + Name: "TestRequestStringByteNullable", + ID: "test_request_string_byte_nullable", } ) - request, close, err := s.decodeTestRequestStringDateNullableRequest(r) + request, close, err := s.decodeTestRequestStringByteNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51799,16 +51808,16 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateNullable", + OperationName: "TestRequestStringByteNullable", OperationSummary: "", - OperationID: "test_request_string_date_nullable", + OperationID: "test_request_string_byte_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilDate + Request = OptNilByte Params = struct{} Response = *Error ) @@ -51821,12 +51830,12 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateNullable(ctx, request) + response, err = s.h.TestRequestStringByteNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateNullable(ctx, request) + response, err = s.h.TestRequestStringByteNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -51834,7 +51843,7 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, args return } - if err := encodeTestRequestStringDateNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51843,18 +51852,18 @@ func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, args } } -// handleTestRequestStringDateNullableArrayRequest handles test_request_string_date_nullable_array operation. +// handleTestRequestStringByteNullableArrayRequest handles test_request_string_byte_nullable_array operation. // -// POST /test_request_string_date_nullable_array -func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_nullable_array +func (s *Server) handleTestRequestStringByteNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable_array"), + otelogen.OperationID("test_request_string_byte_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_byte_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringByteNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51879,11 +51888,11 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateNullableArray", - ID: "test_request_string_date_nullable_array", + Name: "TestRequestStringByteNullableArray", + ID: "test_request_string_byte_nullable_array", } ) - request, close, err := s.decodeTestRequestStringDateNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringByteNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -51903,16 +51912,16 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateNullableArray", + OperationName: "TestRequestStringByteNullableArray", OperationSummary: "", - OperationID: "test_request_string_date_nullable_array", + OperationID: "test_request_string_byte_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilDate + Request = [][]byte Params = struct{} Response = *Error ) @@ -51925,12 +51934,12 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateNullableArray(ctx, request) + response, err = s.h.TestRequestStringByteNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateNullableArray(ctx, request) + response, err = s.h.TestRequestStringByteNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -51938,7 +51947,7 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringDateNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -51947,18 +51956,18 @@ func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, } } -// handleTestRequestStringDateNullableArrayArrayRequest handles test_request_string_date_nullable_array_array operation. +// handleTestRequestStringByteNullableArrayArrayRequest handles test_request_string_byte_nullable_array_array operation. // -// POST /test_request_string_date_nullable_array_array -func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_byte_nullable_array_array +func (s *Server) handleTestRequestStringByteNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date_nullable_array_array"), + otelogen.OperationID("test_request_string_byte_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_byte_nullable_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(), "TestRequestStringByteNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -51983,11 +51992,11 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateNullableArrayArray", - ID: "test_request_string_date_nullable_array_array", + Name: "TestRequestStringByteNullableArrayArray", + ID: "test_request_string_byte_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringDateNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringByteNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52007,16 +52016,16 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateNullableArrayArray", + OperationName: "TestRequestStringByteNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_date_nullable_array_array", + OperationID: "test_request_string_byte_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilDate + Request = [][][]byte Params = struct{} Response = *Error ) @@ -52029,12 +52038,12 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringByteNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringByteNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -52042,7 +52051,7 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringDateNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringByteNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52051,18 +52060,18 @@ func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringDateTimeRequest handles test_request_string_date-time operation. +// handleTestRequestStringDateRequest handles test_request_string_date operation. // -// POST /test_request_string_date-time -func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date +func (s *Server) handleTestRequestStringDateRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time"), + otelogen.OperationID("test_request_string_date"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date-time"), + semconv.HTTPRouteKey.String("/test_request_string_date"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDate", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52087,11 +52096,11 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTime", - ID: "test_request_string_date-time", + Name: "TestRequestStringDate", + ID: "test_request_string_date", } ) - request, close, err := s.decodeTestRequestStringDateTimeRequest(r) + request, close, err := s.decodeTestRequestStringDateRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52111,16 +52120,16 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTime", + OperationName: "TestRequestStringDate", OperationSummary: "", - OperationID: "test_request_string_date-time", + OperationID: "test_request_string_date", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptDateTime + Request = OptDate Params = struct{} Response = *Error ) @@ -52133,12 +52142,12 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateTime(ctx, request) + response, err = s.h.TestRequestStringDate(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateTime(ctx, request) + response, err = s.h.TestRequestStringDate(ctx, request) } if err != nil { recordError("Internal", err) @@ -52146,7 +52155,7 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringDateTimeResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52155,18 +52164,18 @@ func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, argsEsca } } -// handleTestRequestStringDateTimeArrayRequest handles test_request_string_date-time_array operation. +// handleTestRequestStringDateArrayRequest handles test_request_string_date_array operation. // -// POST /test_request_string_date-time_array -func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_array +func (s *Server) handleTestRequestStringDateArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_array"), + otelogen.OperationID("test_request_string_date_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date-time_array"), + semconv.HTTPRouteKey.String("/test_request_string_date_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52191,11 +52200,11 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeArray", - ID: "test_request_string_date-time_array", + Name: "TestRequestStringDateArray", + ID: "test_request_string_date_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52215,9 +52224,9 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeArray", + OperationName: "TestRequestStringDateArray", OperationSummary: "", - OperationID: "test_request_string_date-time_array", + OperationID: "test_request_string_date_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -52237,12 +52246,12 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateTimeArray(ctx, request) + response, err = s.h.TestRequestStringDateArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateTimeArray(ctx, request) + response, err = s.h.TestRequestStringDateArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -52250,7 +52259,7 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringDateTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52259,18 +52268,18 @@ func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, arg } } -// handleTestRequestStringDateTimeArrayArrayRequest handles test_request_string_date-time_array_array operation. +// handleTestRequestStringDateArrayArrayRequest handles test_request_string_date_array_array operation. // -// POST /test_request_string_date-time_array_array -func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_array_array +func (s *Server) handleTestRequestStringDateArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_array_array"), + otelogen.OperationID("test_request_string_date_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date-time_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_date_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(), "TestRequestStringDateArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52295,11 +52304,11 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeArrayArray", - ID: "test_request_string_date-time_array_array", + Name: "TestRequestStringDateArrayArray", + ID: "test_request_string_date_array_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52319,9 +52328,9 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeArrayArray", + OperationName: "TestRequestStringDateArrayArray", OperationSummary: "", - OperationID: "test_request_string_date-time_array_array", + OperationID: "test_request_string_date_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -52341,12 +52350,12 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateTimeArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateTimeArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -52354,7 +52363,7 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringDateTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52363,18 +52372,18 @@ func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string } } -// handleTestRequestStringDateTimeNullableRequest handles test_request_string_date-time_nullable operation. +// handleTestRequestStringDateNullableRequest handles test_request_string_date_nullable operation. // -// POST /test_request_string_date-time_nullable -func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_nullable +func (s *Server) handleTestRequestStringDateNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable"), + otelogen.OperationID("test_request_string_date_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date-time_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_date_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52399,11 +52408,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeNullable", - ID: "test_request_string_date-time_nullable", + Name: "TestRequestStringDateNullable", + ID: "test_request_string_date_nullable", } ) - request, close, err := s.decodeTestRequestStringDateTimeNullableRequest(r) + request, close, err := s.decodeTestRequestStringDateNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52423,16 +52432,16 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeNullable", + OperationName: "TestRequestStringDateNullable", OperationSummary: "", - OperationID: "test_request_string_date-time_nullable", + OperationID: "test_request_string_date_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilDateTime + Request = OptNilDate Params = struct{} Response = *Error ) @@ -52445,12 +52454,12 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateTimeNullable(ctx, request) + response, err = s.h.TestRequestStringDateNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateTimeNullable(ctx, request) + response, err = s.h.TestRequestStringDateNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -52458,7 +52467,7 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, return } - if err := encodeTestRequestStringDateTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52467,18 +52476,18 @@ func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, } } -// handleTestRequestStringDateTimeNullableArrayRequest handles test_request_string_date-time_nullable_array operation. +// handleTestRequestStringDateNullableArrayRequest handles test_request_string_date_nullable_array operation. // -// POST /test_request_string_date-time_nullable_array -func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_nullable_array +func (s *Server) handleTestRequestStringDateNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable_array"), + otelogen.OperationID("test_request_string_date_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date-time_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_date_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52503,11 +52512,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeNullableArray", - ID: "test_request_string_date-time_nullable_array", + Name: "TestRequestStringDateNullableArray", + ID: "test_request_string_date_nullable_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52527,16 +52536,16 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeNullableArray", + OperationName: "TestRequestStringDateNullableArray", OperationSummary: "", - OperationID: "test_request_string_date-time_nullable_array", + OperationID: "test_request_string_date_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilDateTime + Request = []NilDate Params = struct{} Response = *Error ) @@ -52549,12 +52558,12 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateTimeNullableArray(ctx, request) + response, err = s.h.TestRequestStringDateNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateTimeNullableArray(ctx, request) + response, err = s.h.TestRequestStringDateNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -52562,7 +52571,7 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringDateTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52571,18 +52580,18 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]str } } -// handleTestRequestStringDateTimeNullableArrayArrayRequest handles test_request_string_date-time_nullable_array_array operation. +// handleTestRequestStringDateNullableArrayArrayRequest handles test_request_string_date_nullable_array_array operation. // -// POST /test_request_string_date-time_nullable_array_array -func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date_nullable_array_array +func (s *Server) handleTestRequestStringDateNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_date-time_nullable_array_array"), + otelogen.OperationID("test_request_string_date_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_date-time_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_date_nullable_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(), "TestRequestStringDateNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52607,11 +52616,11 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDateTimeNullableArrayArray", - ID: "test_request_string_date-time_nullable_array_array", + Name: "TestRequestStringDateNullableArrayArray", + ID: "test_request_string_date_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringDateTimeNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52631,16 +52640,16 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDateTimeNullableArrayArray", + OperationName: "TestRequestStringDateNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_date-time_nullable_array_array", + OperationID: "test_request_string_date_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilDateTime + Request = [][]NilDate Params = struct{} Response = *Error ) @@ -52653,12 +52662,12 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -52666,7 +52675,7 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52675,18 +52684,18 @@ func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [ } } -// handleTestRequestStringDurationRequest handles test_request_string_duration operation. +// handleTestRequestStringDateTimeRequest handles test_request_string_date-time operation. // -// POST /test_request_string_duration -func (s *Server) handleTestRequestStringDurationRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time +func (s *Server) handleTestRequestStringDateTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration"), + otelogen.OperationID("test_request_string_date-time"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_duration"), + semconv.HTTPRouteKey.String("/test_request_string_date-time"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDuration", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTime", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52711,11 +52720,11 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDuration", - ID: "test_request_string_duration", + Name: "TestRequestStringDateTime", + ID: "test_request_string_date-time", } ) - request, close, err := s.decodeTestRequestStringDurationRequest(r) + request, close, err := s.decodeTestRequestStringDateTimeRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52735,16 +52744,16 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDuration", + OperationName: "TestRequestStringDateTime", OperationSummary: "", - OperationID: "test_request_string_duration", + OperationID: "test_request_string_date-time", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptDuration + Request = OptDateTime Params = struct{} Response = *Error ) @@ -52757,12 +52766,12 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDuration(ctx, request) + response, err = s.h.TestRequestStringDateTime(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDuration(ctx, request) + response, err = s.h.TestRequestStringDateTime(ctx, request) } if err != nil { recordError("Internal", err) @@ -52770,7 +52779,7 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringDurationResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52779,18 +52788,18 @@ func (s *Server) handleTestRequestStringDurationRequest(args [0]string, argsEsca } } -// handleTestRequestStringDurationArrayRequest handles test_request_string_duration_array operation. +// handleTestRequestStringDateTimeArrayRequest handles test_request_string_date-time_array operation. // -// POST /test_request_string_duration_array -func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_array +func (s *Server) handleTestRequestStringDateTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_array"), + otelogen.OperationID("test_request_string_date-time_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_duration_array"), + semconv.HTTPRouteKey.String("/test_request_string_date-time_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52815,11 +52824,11 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationArray", - ID: "test_request_string_duration_array", + Name: "TestRequestStringDateTimeArray", + ID: "test_request_string_date-time_array", } ) - request, close, err := s.decodeTestRequestStringDurationArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateTimeArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52839,16 +52848,16 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationArray", + OperationName: "TestRequestStringDateTimeArray", OperationSummary: "", - OperationID: "test_request_string_duration_array", + OperationID: "test_request_string_date-time_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Duration + Request = []time.Time Params = struct{} Response = *Error ) @@ -52861,12 +52870,12 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDurationArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDurationArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -52874,7 +52883,7 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringDurationArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52883,18 +52892,18 @@ func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, arg } } -// handleTestRequestStringDurationArrayArrayRequest handles test_request_string_duration_array_array operation. +// handleTestRequestStringDateTimeArrayArrayRequest handles test_request_string_date-time_array_array operation. // -// POST /test_request_string_duration_array_array -func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_array_array +func (s *Server) handleTestRequestStringDateTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_array_array"), + otelogen.OperationID("test_request_string_date-time_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_duration_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_date-time_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(), "TestRequestStringDateTimeArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -52919,11 +52928,11 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationArrayArray", - ID: "test_request_string_duration_array_array", + Name: "TestRequestStringDateTimeArrayArray", + ID: "test_request_string_date-time_array_array", } ) - request, close, err := s.decodeTestRequestStringDurationArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateTimeArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -52943,16 +52952,16 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationArrayArray", + OperationName: "TestRequestStringDateTimeArrayArray", OperationSummary: "", - OperationID: "test_request_string_duration_array_array", + OperationID: "test_request_string_date-time_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Duration + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -52965,12 +52974,12 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDurationArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDurationArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -52978,7 +52987,7 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringDurationArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -52987,18 +52996,18 @@ func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string } } -// handleTestRequestStringDurationNullableRequest handles test_request_string_duration_nullable operation. +// handleTestRequestStringDateTimeNullableRequest handles test_request_string_date-time_nullable operation. // -// POST /test_request_string_duration_nullable -func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_nullable +func (s *Server) handleTestRequestStringDateTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable"), + otelogen.OperationID("test_request_string_date-time_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_duration_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_date-time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53023,11 +53032,11 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationNullable", - ID: "test_request_string_duration_nullable", + Name: "TestRequestStringDateTimeNullable", + ID: "test_request_string_date-time_nullable", } ) - request, close, err := s.decodeTestRequestStringDurationNullableRequest(r) + request, close, err := s.decodeTestRequestStringDateTimeNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53047,16 +53056,16 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationNullable", + OperationName: "TestRequestStringDateTimeNullable", OperationSummary: "", - OperationID: "test_request_string_duration_nullable", + OperationID: "test_request_string_date-time_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilDuration + Request = OptNilDateTime Params = struct{} Response = *Error ) @@ -53069,12 +53078,12 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDurationNullable(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDurationNullable(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -53082,7 +53091,7 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, return } - if err := encodeTestRequestStringDurationNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53091,18 +53100,18 @@ func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, } } -// handleTestRequestStringDurationNullableArrayRequest handles test_request_string_duration_nullable_array operation. +// handleTestRequestStringDateTimeNullableArrayRequest handles test_request_string_date-time_nullable_array operation. // -// POST /test_request_string_duration_nullable_array -func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_nullable_array +func (s *Server) handleTestRequestStringDateTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable_array"), + otelogen.OperationID("test_request_string_date-time_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_duration_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_date-time_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDateTimeNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53127,11 +53136,11 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationNullableArray", - ID: "test_request_string_duration_nullable_array", + Name: "TestRequestStringDateTimeNullableArray", + ID: "test_request_string_date-time_nullable_array", } ) - request, close, err := s.decodeTestRequestStringDurationNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateTimeNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53151,16 +53160,16 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationNullableArray", + OperationName: "TestRequestStringDateTimeNullableArray", OperationSummary: "", - OperationID: "test_request_string_duration_nullable_array", + OperationID: "test_request_string_date-time_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilDuration + Request = []NilDateTime Params = struct{} Response = *Error ) @@ -53173,12 +53182,12 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDurationNullableArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDurationNullableArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -53186,7 +53195,7 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringDurationNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53195,18 +53204,18 @@ func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]str } } -// handleTestRequestStringDurationNullableArrayArrayRequest handles test_request_string_duration_nullable_array_array operation. +// handleTestRequestStringDateTimeNullableArrayArrayRequest handles test_request_string_date-time_nullable_array_array operation. // -// POST /test_request_string_duration_nullable_array_array -func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_date-time_nullable_array_array +func (s *Server) handleTestRequestStringDateTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_duration_nullable_array_array"), + otelogen.OperationID("test_request_string_date-time_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_duration_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_date-time_nullable_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(), "TestRequestStringDateTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53231,11 +53240,11 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringDurationNullableArrayArray", - ID: "test_request_string_duration_nullable_array_array", + Name: "TestRequestStringDateTimeNullableArrayArray", + ID: "test_request_string_date-time_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringDurationNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringDateTimeNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53255,16 +53264,16 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringDurationNullableArrayArray", + OperationName: "TestRequestStringDateTimeNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_duration_nullable_array_array", + OperationID: "test_request_string_date-time_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilDuration + Request = [][]NilDateTime Params = struct{} Response = *Error ) @@ -53277,12 +53286,12 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringDurationNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringDurationNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDateTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -53290,7 +53299,7 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringDurationNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53299,18 +53308,18 @@ func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [ } } -// handleTestRequestStringEmailRequest handles test_request_string_email operation. +// handleTestRequestStringDurationRequest handles test_request_string_duration operation. // -// POST /test_request_string_email -func (s *Server) handleTestRequestStringEmailRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration +func (s *Server) handleTestRequestStringDurationRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email"), + otelogen.OperationID("test_request_string_duration"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_email"), + semconv.HTTPRouteKey.String("/test_request_string_duration"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmail", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDuration", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53335,11 +53344,11 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmail", - ID: "test_request_string_email", + Name: "TestRequestStringDuration", + ID: "test_request_string_duration", } ) - request, close, err := s.decodeTestRequestStringEmailRequest(r) + request, close, err := s.decodeTestRequestStringDurationRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53359,16 +53368,16 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmail", + OperationName: "TestRequestStringDuration", OperationSummary: "", - OperationID: "test_request_string_email", + OperationID: "test_request_string_duration", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptString + Request = OptDuration Params = struct{} Response = *Error ) @@ -53381,12 +53390,12 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringEmail(ctx, request) + response, err = s.h.TestRequestStringDuration(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringEmail(ctx, request) + response, err = s.h.TestRequestStringDuration(ctx, request) } if err != nil { recordError("Internal", err) @@ -53394,7 +53403,7 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringEmailResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53403,18 +53412,18 @@ func (s *Server) handleTestRequestStringEmailRequest(args [0]string, argsEscaped } } -// handleTestRequestStringEmailArrayRequest handles test_request_string_email_array operation. +// handleTestRequestStringDurationArrayRequest handles test_request_string_duration_array operation. // -// POST /test_request_string_email_array -func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_array +func (s *Server) handleTestRequestStringDurationArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_array"), + otelogen.OperationID("test_request_string_duration_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_email_array"), + semconv.HTTPRouteKey.String("/test_request_string_duration_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53439,11 +53448,11 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailArray", - ID: "test_request_string_email_array", + Name: "TestRequestStringDurationArray", + ID: "test_request_string_duration_array", } ) - request, close, err := s.decodeTestRequestStringEmailArrayRequest(r) + request, close, err := s.decodeTestRequestStringDurationArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53463,16 +53472,16 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailArray", + OperationName: "TestRequestStringDurationArray", OperationSummary: "", - OperationID: "test_request_string_email_array", + OperationID: "test_request_string_duration_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []string + Request = []time.Duration Params = struct{} Response = *Error ) @@ -53485,12 +53494,12 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringEmailArray(ctx, request) + response, err = s.h.TestRequestStringDurationArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringEmailArray(ctx, request) + response, err = s.h.TestRequestStringDurationArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -53498,7 +53507,7 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, argsEs return } - if err := encodeTestRequestStringEmailArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53507,18 +53516,18 @@ func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, argsEs } } -// handleTestRequestStringEmailArrayArrayRequest handles test_request_string_email_array_array operation. +// handleTestRequestStringDurationArrayArrayRequest handles test_request_string_duration_array_array operation. // -// POST /test_request_string_email_array_array -func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_array_array +func (s *Server) handleTestRequestStringDurationArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_array_array"), + otelogen.OperationID("test_request_string_duration_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_email_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_duration_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(), "TestRequestStringDurationArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53543,11 +53552,11 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailArrayArray", - ID: "test_request_string_email_array_array", + Name: "TestRequestStringDurationArrayArray", + ID: "test_request_string_duration_array_array", } ) - request, close, err := s.decodeTestRequestStringEmailArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringDurationArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53567,16 +53576,16 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailArrayArray", + OperationName: "TestRequestStringDurationArrayArray", OperationSummary: "", - OperationID: "test_request_string_email_array_array", + OperationID: "test_request_string_duration_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]string + Request = [][]time.Duration Params = struct{} Response = *Error ) @@ -53589,12 +53598,12 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringEmailArrayArray(ctx, request) + response, err = s.h.TestRequestStringDurationArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringEmailArrayArray(ctx, request) + response, err = s.h.TestRequestStringDurationArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -53602,7 +53611,7 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, a return } - if err := encodeTestRequestStringEmailArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53611,18 +53620,18 @@ func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, a } } -// handleTestRequestStringEmailNullableRequest handles test_request_string_email_nullable operation. +// handleTestRequestStringDurationNullableRequest handles test_request_string_duration_nullable operation. // -// POST /test_request_string_email_nullable -func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_nullable +func (s *Server) handleTestRequestStringDurationNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable"), + otelogen.OperationID("test_request_string_duration_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_email_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_duration_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringDurationNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53647,11 +53656,11 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailNullable", - ID: "test_request_string_email_nullable", + Name: "TestRequestStringDurationNullable", + ID: "test_request_string_duration_nullable", } ) - request, close, err := s.decodeTestRequestStringEmailNullableRequest(r) + request, close, err := s.decodeTestRequestStringDurationNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53671,16 +53680,16 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailNullable", + OperationName: "TestRequestStringDurationNullable", OperationSummary: "", - OperationID: "test_request_string_email_nullable", + OperationID: "test_request_string_duration_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilString + Request = OptNilDuration Params = struct{} Response = *Error ) @@ -53693,12 +53702,12 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringEmailNullable(ctx, request) + response, err = s.h.TestRequestStringDurationNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringEmailNullable(ctx, request) + response, err = s.h.TestRequestStringDurationNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -53706,7 +53715,7 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, arg return } - if err := encodeTestRequestStringEmailNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53715,18 +53724,18 @@ func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, arg } } -// handleTestRequestStringEmailNullableArrayRequest handles test_request_string_email_nullable_array operation. +// handleTestRequestStringDurationNullableArrayRequest handles test_request_string_duration_nullable_array operation. // -// POST /test_request_string_email_nullable_array -func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_nullable_array +func (s *Server) handleTestRequestStringDurationNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable_array"), + otelogen.OperationID("test_request_string_duration_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_email_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_duration_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(), "TestRequestStringDurationNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53751,11 +53760,11 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailNullableArray", - ID: "test_request_string_email_nullable_array", + Name: "TestRequestStringDurationNullableArray", + ID: "test_request_string_duration_nullable_array", } ) - request, close, err := s.decodeTestRequestStringEmailNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringDurationNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53775,16 +53784,16 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailNullableArray", + OperationName: "TestRequestStringDurationNullableArray", OperationSummary: "", - OperationID: "test_request_string_email_nullable_array", + OperationID: "test_request_string_duration_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilString + Request = []NilDuration Params = struct{} Response = *Error ) @@ -53797,12 +53806,12 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringEmailNullableArray(ctx, request) + response, err = s.h.TestRequestStringDurationNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringEmailNullableArray(ctx, request) + response, err = s.h.TestRequestStringDurationNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -53810,7 +53819,7 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringEmailNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53819,18 +53828,18 @@ func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string } } -// handleTestRequestStringEmailNullableArrayArrayRequest handles test_request_string_email_nullable_array_array operation. +// handleTestRequestStringDurationNullableArrayArrayRequest handles test_request_string_duration_nullable_array_array operation. // -// POST /test_request_string_email_nullable_array_array -func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_duration_nullable_array_array +func (s *Server) handleTestRequestStringDurationNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_email_nullable_array_array"), + otelogen.OperationID("test_request_string_duration_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_email_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_duration_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(), "TestRequestStringDurationNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53855,11 +53864,11 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringEmailNullableArrayArray", - ID: "test_request_string_email_nullable_array_array", + Name: "TestRequestStringDurationNullableArrayArray", + ID: "test_request_string_duration_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringEmailNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringDurationNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53879,16 +53888,16 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringEmailNullableArrayArray", + OperationName: "TestRequestStringDurationNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_email_nullable_array_array", + OperationID: "test_request_string_duration_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilDuration Params = struct{} Response = *Error ) @@ -53901,12 +53910,12 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringEmailNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDurationNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringEmailNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringDurationNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -53914,7 +53923,7 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringEmailNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringDurationNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -53923,18 +53932,18 @@ func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]s } } -// handleTestRequestStringFloat32Request handles test_request_string_float32 operation. +// handleTestRequestStringEmailRequest handles test_request_string_email operation. // -// POST /test_request_string_float32 -func (s *Server) handleTestRequestStringFloat32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email +func (s *Server) handleTestRequestStringEmailRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float32"), + otelogen.OperationID("test_request_string_email"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float32"), + semconv.HTTPRouteKey.String("/test_request_string_email"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmail", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -53959,11 +53968,11 @@ func (s *Server) handleTestRequestStringFloat32Request(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat32", - ID: "test_request_string_float32", + Name: "TestRequestStringEmail", + ID: "test_request_string_email", } ) - request, close, err := s.decodeTestRequestStringFloat32Request(r) + request, close, err := s.decodeTestRequestStringEmailRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -53983,16 +53992,16 @@ func (s *Server) handleTestRequestStringFloat32Request(args [0]string, argsEscap if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat32", + OperationName: "TestRequestStringEmail", OperationSummary: "", - OperationID: "test_request_string_float32", + OperationID: "test_request_string_email", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringFloat32 + Request = OptString Params = struct{} Response = *Error ) @@ -54005,12 +54014,12 @@ func (s *Server) handleTestRequestStringFloat32Request(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat32(ctx, request) + response, err = s.h.TestRequestStringEmail(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat32(ctx, request) + response, err = s.h.TestRequestStringEmail(ctx, request) } if err != nil { recordError("Internal", err) @@ -54018,7 +54027,7 @@ func (s *Server) handleTestRequestStringFloat32Request(args [0]string, argsEscap return } - if err := encodeTestRequestStringFloat32Response(response, w, span); err != nil { + if err := encodeTestRequestStringEmailResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54027,18 +54036,18 @@ func (s *Server) handleTestRequestStringFloat32Request(args [0]string, argsEscap } } -// handleTestRequestStringFloat32ArrayRequest handles test_request_string_float32_array operation. +// handleTestRequestStringEmailArrayRequest handles test_request_string_email_array operation. // -// POST /test_request_string_float32_array -func (s *Server) handleTestRequestStringFloat32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_array +func (s *Server) handleTestRequestStringEmailArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float32_array"), + otelogen.OperationID("test_request_string_email_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float32_array"), + semconv.HTTPRouteKey.String("/test_request_string_email_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54063,11 +54072,11 @@ func (s *Server) handleTestRequestStringFloat32ArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat32Array", - ID: "test_request_string_float32_array", + Name: "TestRequestStringEmailArray", + ID: "test_request_string_email_array", } ) - request, close, err := s.decodeTestRequestStringFloat32ArrayRequest(r) + request, close, err := s.decodeTestRequestStringEmailArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54087,16 +54096,16 @@ func (s *Server) handleTestRequestStringFloat32ArrayRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat32Array", + OperationName: "TestRequestStringEmailArray", OperationSummary: "", - OperationID: "test_request_string_float32_array", + OperationID: "test_request_string_email_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []float32 + Request = []string Params = struct{} Response = *Error ) @@ -54109,12 +54118,12 @@ func (s *Server) handleTestRequestStringFloat32ArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat32Array(ctx, request) + response, err = s.h.TestRequestStringEmailArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat32Array(ctx, request) + response, err = s.h.TestRequestStringEmailArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -54122,7 +54131,7 @@ func (s *Server) handleTestRequestStringFloat32ArrayRequest(args [0]string, args return } - if err := encodeTestRequestStringFloat32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54131,18 +54140,18 @@ func (s *Server) handleTestRequestStringFloat32ArrayRequest(args [0]string, args } } -// handleTestRequestStringFloat32ArrayArrayRequest handles test_request_string_float32_array_array operation. +// handleTestRequestStringEmailArrayArrayRequest handles test_request_string_email_array_array operation. // -// POST /test_request_string_float32_array_array -func (s *Server) handleTestRequestStringFloat32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_array_array +func (s *Server) handleTestRequestStringEmailArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float32_array_array"), + otelogen.OperationID("test_request_string_email_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float32_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_email_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54167,11 +54176,11 @@ func (s *Server) handleTestRequestStringFloat32ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat32ArrayArray", - ID: "test_request_string_float32_array_array", + Name: "TestRequestStringEmailArrayArray", + ID: "test_request_string_email_array_array", } ) - request, close, err := s.decodeTestRequestStringFloat32ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringEmailArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54191,16 +54200,16 @@ func (s *Server) handleTestRequestStringFloat32ArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat32ArrayArray", + OperationName: "TestRequestStringEmailArrayArray", OperationSummary: "", - OperationID: "test_request_string_float32_array_array", + OperationID: "test_request_string_email_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]float32 + Request = [][]string Params = struct{} Response = *Error ) @@ -54213,12 +54222,12 @@ func (s *Server) handleTestRequestStringFloat32ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat32ArrayArray(ctx, request) + response, err = s.h.TestRequestStringEmailArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat32ArrayArray(ctx, request) + response, err = s.h.TestRequestStringEmailArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -54226,7 +54235,7 @@ func (s *Server) handleTestRequestStringFloat32ArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringFloat32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54235,18 +54244,18 @@ func (s *Server) handleTestRequestStringFloat32ArrayArrayRequest(args [0]string, } } -// handleTestRequestStringFloat32NullableRequest handles test_request_string_float32_nullable operation. +// handleTestRequestStringEmailNullableRequest handles test_request_string_email_nullable operation. // -// POST /test_request_string_float32_nullable -func (s *Server) handleTestRequestStringFloat32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_nullable +func (s *Server) handleTestRequestStringEmailNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float32_nullable"), + otelogen.OperationID("test_request_string_email_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float32_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_email_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54271,11 +54280,11 @@ func (s *Server) handleTestRequestStringFloat32NullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat32Nullable", - ID: "test_request_string_float32_nullable", + Name: "TestRequestStringEmailNullable", + ID: "test_request_string_email_nullable", } ) - request, close, err := s.decodeTestRequestStringFloat32NullableRequest(r) + request, close, err := s.decodeTestRequestStringEmailNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54295,16 +54304,16 @@ func (s *Server) handleTestRequestStringFloat32NullableRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat32Nullable", + OperationName: "TestRequestStringEmailNullable", OperationSummary: "", - OperationID: "test_request_string_float32_nullable", + OperationID: "test_request_string_email_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringFloat32 + Request = OptNilString Params = struct{} Response = *Error ) @@ -54317,12 +54326,12 @@ func (s *Server) handleTestRequestStringFloat32NullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat32Nullable(ctx, request) + response, err = s.h.TestRequestStringEmailNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat32Nullable(ctx, request) + response, err = s.h.TestRequestStringEmailNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -54330,7 +54339,7 @@ func (s *Server) handleTestRequestStringFloat32NullableRequest(args [0]string, a return } - if err := encodeTestRequestStringFloat32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54339,18 +54348,18 @@ func (s *Server) handleTestRequestStringFloat32NullableRequest(args [0]string, a } } -// handleTestRequestStringFloat32NullableArrayRequest handles test_request_string_float32_nullable_array operation. +// handleTestRequestStringEmailNullableArrayRequest handles test_request_string_email_nullable_array operation. // -// POST /test_request_string_float32_nullable_array -func (s *Server) handleTestRequestStringFloat32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_nullable_array +func (s *Server) handleTestRequestStringEmailNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float32_nullable_array"), + otelogen.OperationID("test_request_string_email_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float32_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_email_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54375,11 +54384,11 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat32NullableArray", - ID: "test_request_string_float32_nullable_array", + Name: "TestRequestStringEmailNullableArray", + ID: "test_request_string_email_nullable_array", } ) - request, close, err := s.decodeTestRequestStringFloat32NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringEmailNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54399,16 +54408,16 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat32NullableArray", + OperationName: "TestRequestStringEmailNullableArray", OperationSummary: "", - OperationID: "test_request_string_float32_nullable_array", + OperationID: "test_request_string_email_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringFloat32 + Request = []NilString Params = struct{} Response = *Error ) @@ -54421,12 +54430,12 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat32NullableArray(ctx, request) + response, err = s.h.TestRequestStringEmailNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat32NullableArray(ctx, request) + response, err = s.h.TestRequestStringEmailNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -54434,7 +54443,7 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayRequest(args [0]stri return } - if err := encodeTestRequestStringFloat32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54443,18 +54452,18 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayRequest(args [0]stri } } -// handleTestRequestStringFloat32NullableArrayArrayRequest handles test_request_string_float32_nullable_array_array operation. +// handleTestRequestStringEmailNullableArrayArrayRequest handles test_request_string_email_nullable_array_array operation. // -// POST /test_request_string_float32_nullable_array_array -func (s *Server) handleTestRequestStringFloat32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_email_nullable_array_array +func (s *Server) handleTestRequestStringEmailNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float32_nullable_array_array"), + otelogen.OperationID("test_request_string_email_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_email_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringEmailNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54479,11 +54488,11 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat32NullableArrayArray", - ID: "test_request_string_float32_nullable_array_array", + Name: "TestRequestStringEmailNullableArrayArray", + ID: "test_request_string_email_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringFloat32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringEmailNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54503,16 +54512,16 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat32NullableArrayArray", + OperationName: "TestRequestStringEmailNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_float32_nullable_array_array", + OperationID: "test_request_string_email_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringFloat32 + Request = [][]NilString Params = struct{} Response = *Error ) @@ -54525,12 +54534,12 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringEmailNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringEmailNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -54538,7 +54547,7 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayArrayRequest(args [0 return } - if err := encodeTestRequestStringFloat32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringEmailNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54547,18 +54556,18 @@ func (s *Server) handleTestRequestStringFloat32NullableArrayArrayRequest(args [0 } } -// handleTestRequestStringFloat64Request handles test_request_string_float64 operation. +// handleTestRequestStringFloat32Request handles test_request_string_float32 operation. // -// POST /test_request_string_float64 -func (s *Server) handleTestRequestStringFloat64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float32 +func (s *Server) handleTestRequestStringFloat32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float64"), + otelogen.OperationID("test_request_string_float32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float64"), + semconv.HTTPRouteKey.String("/test_request_string_float32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54583,11 +54592,11 @@ func (s *Server) handleTestRequestStringFloat64Request(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat64", - ID: "test_request_string_float64", + Name: "TestRequestStringFloat32", + ID: "test_request_string_float32", } ) - request, close, err := s.decodeTestRequestStringFloat64Request(r) + request, close, err := s.decodeTestRequestStringFloat32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54607,16 +54616,16 @@ func (s *Server) handleTestRequestStringFloat64Request(args [0]string, argsEscap if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat64", + OperationName: "TestRequestStringFloat32", OperationSummary: "", - OperationID: "test_request_string_float64", + OperationID: "test_request_string_float32", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringFloat64 + Request = OptStringFloat32 Params = struct{} Response = *Error ) @@ -54629,12 +54638,12 @@ func (s *Server) handleTestRequestStringFloat64Request(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat64(ctx, request) + response, err = s.h.TestRequestStringFloat32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat64(ctx, request) + response, err = s.h.TestRequestStringFloat32(ctx, request) } if err != nil { recordError("Internal", err) @@ -54642,7 +54651,7 @@ func (s *Server) handleTestRequestStringFloat64Request(args [0]string, argsEscap return } - if err := encodeTestRequestStringFloat64Response(response, w, span); err != nil { + if err := encodeTestRequestStringFloat32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54651,18 +54660,18 @@ func (s *Server) handleTestRequestStringFloat64Request(args [0]string, argsEscap } } -// handleTestRequestStringFloat64ArrayRequest handles test_request_string_float64_array operation. +// handleTestRequestStringFloat32ArrayRequest handles test_request_string_float32_array operation. // -// POST /test_request_string_float64_array -func (s *Server) handleTestRequestStringFloat64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float32_array +func (s *Server) handleTestRequestStringFloat32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float64_array"), + otelogen.OperationID("test_request_string_float32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float64_array"), + semconv.HTTPRouteKey.String("/test_request_string_float32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54687,11 +54696,11 @@ func (s *Server) handleTestRequestStringFloat64ArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat64Array", - ID: "test_request_string_float64_array", + Name: "TestRequestStringFloat32Array", + ID: "test_request_string_float32_array", } ) - request, close, err := s.decodeTestRequestStringFloat64ArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54711,16 +54720,16 @@ func (s *Server) handleTestRequestStringFloat64ArrayRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat64Array", + OperationName: "TestRequestStringFloat32Array", OperationSummary: "", - OperationID: "test_request_string_float64_array", + OperationID: "test_request_string_float32_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []float64 + Request = []float32 Params = struct{} Response = *Error ) @@ -54733,12 +54742,12 @@ func (s *Server) handleTestRequestStringFloat64ArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat64Array(ctx, request) + response, err = s.h.TestRequestStringFloat32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat64Array(ctx, request) + response, err = s.h.TestRequestStringFloat32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -54746,7 +54755,7 @@ func (s *Server) handleTestRequestStringFloat64ArrayRequest(args [0]string, args return } - if err := encodeTestRequestStringFloat64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54755,18 +54764,18 @@ func (s *Server) handleTestRequestStringFloat64ArrayRequest(args [0]string, args } } -// handleTestRequestStringFloat64ArrayArrayRequest handles test_request_string_float64_array_array operation. +// handleTestRequestStringFloat32ArrayArrayRequest handles test_request_string_float32_array_array operation. // -// POST /test_request_string_float64_array_array -func (s *Server) handleTestRequestStringFloat64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float32_array_array +func (s *Server) handleTestRequestStringFloat32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float64_array_array"), + otelogen.OperationID("test_request_string_float32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float64_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_float32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54791,11 +54800,11 @@ func (s *Server) handleTestRequestStringFloat64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat64ArrayArray", - ID: "test_request_string_float64_array_array", + Name: "TestRequestStringFloat32ArrayArray", + ID: "test_request_string_float32_array_array", } ) - request, close, err := s.decodeTestRequestStringFloat64ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54815,16 +54824,16 @@ func (s *Server) handleTestRequestStringFloat64ArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat64ArrayArray", + OperationName: "TestRequestStringFloat32ArrayArray", OperationSummary: "", - OperationID: "test_request_string_float64_array_array", + OperationID: "test_request_string_float32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]float64 + Request = [][]float32 Params = struct{} Response = *Error ) @@ -54837,12 +54846,12 @@ func (s *Server) handleTestRequestStringFloat64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat64ArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat64ArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -54850,7 +54859,7 @@ func (s *Server) handleTestRequestStringFloat64ArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringFloat64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54859,18 +54868,18 @@ func (s *Server) handleTestRequestStringFloat64ArrayArrayRequest(args [0]string, } } -// handleTestRequestStringFloat64NullableRequest handles test_request_string_float64_nullable operation. +// handleTestRequestStringFloat32NullableRequest handles test_request_string_float32_nullable operation. // -// POST /test_request_string_float64_nullable -func (s *Server) handleTestRequestStringFloat64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float32_nullable +func (s *Server) handleTestRequestStringFloat32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float64_nullable"), + otelogen.OperationID("test_request_string_float32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float64_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_float32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54895,11 +54904,11 @@ func (s *Server) handleTestRequestStringFloat64NullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat64Nullable", - ID: "test_request_string_float64_nullable", + Name: "TestRequestStringFloat32Nullable", + ID: "test_request_string_float32_nullable", } ) - request, close, err := s.decodeTestRequestStringFloat64NullableRequest(r) + request, close, err := s.decodeTestRequestStringFloat32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -54919,16 +54928,16 @@ func (s *Server) handleTestRequestStringFloat64NullableRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat64Nullable", + OperationName: "TestRequestStringFloat32Nullable", OperationSummary: "", - OperationID: "test_request_string_float64_nullable", + OperationID: "test_request_string_float32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringFloat64 + Request = OptNilStringFloat32 Params = struct{} Response = *Error ) @@ -54941,12 +54950,12 @@ func (s *Server) handleTestRequestStringFloat64NullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat64Nullable(ctx, request) + response, err = s.h.TestRequestStringFloat32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat64Nullable(ctx, request) + response, err = s.h.TestRequestStringFloat32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -54954,7 +54963,7 @@ func (s *Server) handleTestRequestStringFloat64NullableRequest(args [0]string, a return } - if err := encodeTestRequestStringFloat64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -54963,18 +54972,18 @@ func (s *Server) handleTestRequestStringFloat64NullableRequest(args [0]string, a } } -// handleTestRequestStringFloat64NullableArrayRequest handles test_request_string_float64_nullable_array operation. +// handleTestRequestStringFloat32NullableArrayRequest handles test_request_string_float32_nullable_array operation. // -// POST /test_request_string_float64_nullable_array -func (s *Server) handleTestRequestStringFloat64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float32_nullable_array +func (s *Server) handleTestRequestStringFloat32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float64_nullable_array"), + otelogen.OperationID("test_request_string_float32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float64_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_float32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -54999,11 +55008,11 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat64NullableArray", - ID: "test_request_string_float64_nullable_array", + Name: "TestRequestStringFloat32NullableArray", + ID: "test_request_string_float32_nullable_array", } ) - request, close, err := s.decodeTestRequestStringFloat64NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55023,16 +55032,16 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat64NullableArray", + OperationName: "TestRequestStringFloat32NullableArray", OperationSummary: "", - OperationID: "test_request_string_float64_nullable_array", + OperationID: "test_request_string_float32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringFloat64 + Request = []NilStringFloat32 Params = struct{} Response = *Error ) @@ -55045,12 +55054,12 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat64NullableArray(ctx, request) + response, err = s.h.TestRequestStringFloat32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat64NullableArray(ctx, request) + response, err = s.h.TestRequestStringFloat32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -55058,7 +55067,7 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayRequest(args [0]stri return } - if err := encodeTestRequestStringFloat64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55067,18 +55076,18 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayRequest(args [0]stri } } -// handleTestRequestStringFloat64NullableArrayArrayRequest handles test_request_string_float64_nullable_array_array operation. +// handleTestRequestStringFloat32NullableArrayArrayRequest handles test_request_string_float32_nullable_array_array operation. // -// POST /test_request_string_float64_nullable_array_array -func (s *Server) handleTestRequestStringFloat64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float32_nullable_array_array +func (s *Server) handleTestRequestStringFloat32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_float64_nullable_array_array"), + otelogen.OperationID("test_request_string_float32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_float64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_float32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55103,11 +55112,11 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringFloat64NullableArrayArray", - ID: "test_request_string_float64_nullable_array_array", + Name: "TestRequestStringFloat32NullableArrayArray", + ID: "test_request_string_float32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringFloat64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55127,16 +55136,16 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayArrayRequest(args [0 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringFloat64NullableArrayArray", + OperationName: "TestRequestStringFloat32NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_float64_nullable_array_array", + OperationID: "test_request_string_float32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringFloat64 + Request = [][]NilStringFloat32 Params = struct{} Response = *Error ) @@ -55149,12 +55158,12 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringFloat64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringFloat64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -55162,7 +55171,7 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayArrayRequest(args [0 return } - if err := encodeTestRequestStringFloat64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55171,18 +55180,18 @@ func (s *Server) handleTestRequestStringFloat64NullableArrayArrayRequest(args [0 } } -// handleTestRequestStringHostnameRequest handles test_request_string_hostname operation. +// handleTestRequestStringFloat64Request handles test_request_string_float64 operation. // -// POST /test_request_string_hostname -func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float64 +func (s *Server) handleTestRequestStringFloat64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname"), + otelogen.OperationID("test_request_string_float64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_hostname"), + semconv.HTTPRouteKey.String("/test_request_string_float64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostname", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55207,11 +55216,11 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostname", - ID: "test_request_string_hostname", + Name: "TestRequestStringFloat64", + ID: "test_request_string_float64", } ) - request, close, err := s.decodeTestRequestStringHostnameRequest(r) + request, close, err := s.decodeTestRequestStringFloat64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55231,16 +55240,16 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostname", + OperationName: "TestRequestStringFloat64", OperationSummary: "", - OperationID: "test_request_string_hostname", + OperationID: "test_request_string_float64", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptString + Request = OptStringFloat64 Params = struct{} Response = *Error ) @@ -55253,12 +55262,12 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringHostname(ctx, request) + response, err = s.h.TestRequestStringFloat64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringHostname(ctx, request) + response, err = s.h.TestRequestStringFloat64(ctx, request) } if err != nil { recordError("Internal", err) @@ -55266,7 +55275,7 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringHostnameResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55275,18 +55284,18 @@ func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, argsEsca } } -// handleTestRequestStringHostnameArrayRequest handles test_request_string_hostname_array operation. +// handleTestRequestStringFloat64ArrayRequest handles test_request_string_float64_array operation. // -// POST /test_request_string_hostname_array -func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float64_array +func (s *Server) handleTestRequestStringFloat64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_array"), + otelogen.OperationID("test_request_string_float64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_hostname_array"), + semconv.HTTPRouteKey.String("/test_request_string_float64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55311,11 +55320,11 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameArray", - ID: "test_request_string_hostname_array", + Name: "TestRequestStringFloat64Array", + ID: "test_request_string_float64_array", } ) - request, close, err := s.decodeTestRequestStringHostnameArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55335,16 +55344,16 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameArray", + OperationName: "TestRequestStringFloat64Array", OperationSummary: "", - OperationID: "test_request_string_hostname_array", + OperationID: "test_request_string_float64_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []string + Request = []float64 Params = struct{} Response = *Error ) @@ -55357,12 +55366,12 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringHostnameArray(ctx, request) + response, err = s.h.TestRequestStringFloat64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringHostnameArray(ctx, request) + response, err = s.h.TestRequestStringFloat64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -55370,7 +55379,7 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringHostnameArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55379,18 +55388,18 @@ func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, arg } } -// handleTestRequestStringHostnameArrayArrayRequest handles test_request_string_hostname_array_array operation. +// handleTestRequestStringFloat64ArrayArrayRequest handles test_request_string_float64_array_array operation. // -// POST /test_request_string_hostname_array_array -func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float64_array_array +func (s *Server) handleTestRequestStringFloat64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_array_array"), + otelogen.OperationID("test_request_string_float64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_hostname_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_float64_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(), "TestRequestStringFloat64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55415,11 +55424,11 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameArrayArray", - ID: "test_request_string_hostname_array_array", + Name: "TestRequestStringFloat64ArrayArray", + ID: "test_request_string_float64_array_array", } ) - request, close, err := s.decodeTestRequestStringHostnameArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55439,16 +55448,16 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameArrayArray", + OperationName: "TestRequestStringFloat64ArrayArray", OperationSummary: "", - OperationID: "test_request_string_hostname_array_array", + OperationID: "test_request_string_float64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]string + Request = [][]float64 Params = struct{} Response = *Error ) @@ -55461,12 +55470,12 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringHostnameArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringHostnameArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -55474,7 +55483,7 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringHostnameArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55483,18 +55492,18 @@ func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string } } -// handleTestRequestStringHostnameNullableRequest handles test_request_string_hostname_nullable operation. +// handleTestRequestStringFloat64NullableRequest handles test_request_string_float64_nullable operation. // -// POST /test_request_string_hostname_nullable -func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float64_nullable +func (s *Server) handleTestRequestStringFloat64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable"), + otelogen.OperationID("test_request_string_float64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_hostname_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_float64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringFloat64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55519,11 +55528,11 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameNullable", - ID: "test_request_string_hostname_nullable", + Name: "TestRequestStringFloat64Nullable", + ID: "test_request_string_float64_nullable", } ) - request, close, err := s.decodeTestRequestStringHostnameNullableRequest(r) + request, close, err := s.decodeTestRequestStringFloat64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55543,16 +55552,16 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameNullable", + OperationName: "TestRequestStringFloat64Nullable", OperationSummary: "", - OperationID: "test_request_string_hostname_nullable", + OperationID: "test_request_string_float64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilString + Request = OptNilStringFloat64 Params = struct{} Response = *Error ) @@ -55565,12 +55574,12 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringHostnameNullable(ctx, request) + response, err = s.h.TestRequestStringFloat64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringHostnameNullable(ctx, request) + response, err = s.h.TestRequestStringFloat64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -55578,7 +55587,7 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, return } - if err := encodeTestRequestStringHostnameNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55587,18 +55596,18 @@ func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, } } -// handleTestRequestStringHostnameNullableArrayRequest handles test_request_string_hostname_nullable_array operation. +// handleTestRequestStringFloat64NullableArrayRequest handles test_request_string_float64_nullable_array operation. // -// POST /test_request_string_hostname_nullable_array -func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float64_nullable_array +func (s *Server) handleTestRequestStringFloat64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable_array"), + otelogen.OperationID("test_request_string_float64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_hostname_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_float64_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(), "TestRequestStringFloat64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55623,11 +55632,11 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameNullableArray", - ID: "test_request_string_hostname_nullable_array", + Name: "TestRequestStringFloat64NullableArray", + ID: "test_request_string_float64_nullable_array", } ) - request, close, err := s.decodeTestRequestStringHostnameNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55647,16 +55656,16 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameNullableArray", + OperationName: "TestRequestStringFloat64NullableArray", OperationSummary: "", - OperationID: "test_request_string_hostname_nullable_array", + OperationID: "test_request_string_float64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilString + Request = []NilStringFloat64 Params = struct{} Response = *Error ) @@ -55669,12 +55678,12 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringHostnameNullableArray(ctx, request) + response, err = s.h.TestRequestStringFloat64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringHostnameNullableArray(ctx, request) + response, err = s.h.TestRequestStringFloat64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -55682,7 +55691,7 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringHostnameNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55691,18 +55700,18 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]str } } -// handleTestRequestStringHostnameNullableArrayArrayRequest handles test_request_string_hostname_nullable_array_array operation. +// handleTestRequestStringFloat64NullableArrayArrayRequest handles test_request_string_float64_nullable_array_array operation. // -// POST /test_request_string_hostname_nullable_array_array -func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_float64_nullable_array_array +func (s *Server) handleTestRequestStringFloat64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_hostname_nullable_array_array"), + otelogen.OperationID("test_request_string_float64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_hostname_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_float64_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(), "TestRequestStringFloat64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55727,11 +55736,11 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringHostnameNullableArrayArray", - ID: "test_request_string_hostname_nullable_array_array", + Name: "TestRequestStringFloat64NullableArrayArray", + ID: "test_request_string_float64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringHostnameNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringFloat64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55751,16 +55760,16 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringHostnameNullableArrayArray", + OperationName: "TestRequestStringFloat64NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_hostname_nullable_array_array", + OperationID: "test_request_string_float64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]NilStringFloat64 Params = struct{} Response = *Error ) @@ -55773,12 +55782,12 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringFloat64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -55786,7 +55795,7 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringFloat64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55795,18 +55804,18 @@ func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [ } } -// handleTestRequestStringIPRequest handles test_request_string_ip operation. +// handleTestRequestStringHostnameRequest handles test_request_string_hostname operation. // -// POST /test_request_string_ip -func (s *Server) handleTestRequestStringIPRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname +func (s *Server) handleTestRequestStringHostnameRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip"), + otelogen.OperationID("test_request_string_hostname"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ip"), + semconv.HTTPRouteKey.String("/test_request_string_hostname"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIP", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostname", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55831,11 +55840,11 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, argsEscaped bo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIP", - ID: "test_request_string_ip", + Name: "TestRequestStringHostname", + ID: "test_request_string_hostname", } ) - request, close, err := s.decodeTestRequestStringIPRequest(r) + request, close, err := s.decodeTestRequestStringHostnameRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55855,16 +55864,16 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, argsEscaped bo if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIP", + OperationName: "TestRequestStringHostname", OperationSummary: "", - OperationID: "test_request_string_ip", + OperationID: "test_request_string_hostname", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptIP + Request = OptString Params = struct{} Response = *Error ) @@ -55877,12 +55886,12 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, argsEscaped bo mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIP(ctx, request) + response, err = s.h.TestRequestStringHostname(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIP(ctx, request) + response, err = s.h.TestRequestStringHostname(ctx, request) } if err != nil { recordError("Internal", err) @@ -55890,7 +55899,7 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, argsEscaped bo return } - if err := encodeTestRequestStringIPResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -55899,18 +55908,18 @@ func (s *Server) handleTestRequestStringIPRequest(args [0]string, argsEscaped bo } } -// handleTestRequestStringIPArrayRequest handles test_request_string_ip_array operation. +// handleTestRequestStringHostnameArrayRequest handles test_request_string_hostname_array operation. // -// POST /test_request_string_ip_array -func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_array +func (s *Server) handleTestRequestStringHostnameArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_array"), + otelogen.OperationID("test_request_string_hostname_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ip_array"), + semconv.HTTPRouteKey.String("/test_request_string_hostname_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -55935,11 +55944,11 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPArray", - ID: "test_request_string_ip_array", + Name: "TestRequestStringHostnameArray", + ID: "test_request_string_hostname_array", } ) - request, close, err := s.decodeTestRequestStringIPArrayRequest(r) + request, close, err := s.decodeTestRequestStringHostnameArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -55959,16 +55968,16 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, argsEscap if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPArray", + OperationName: "TestRequestStringHostnameArray", OperationSummary: "", - OperationID: "test_request_string_ip_array", + OperationID: "test_request_string_hostname_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []netip.Addr + Request = []string Params = struct{} Response = *Error ) @@ -55981,12 +55990,12 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIPArray(ctx, request) + response, err = s.h.TestRequestStringHostnameArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIPArray(ctx, request) + response, err = s.h.TestRequestStringHostnameArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -55994,7 +56003,7 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, argsEscap return } - if err := encodeTestRequestStringIPArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56003,18 +56012,18 @@ func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, argsEscap } } -// handleTestRequestStringIPArrayArrayRequest handles test_request_string_ip_array_array operation. +// handleTestRequestStringHostnameArrayArrayRequest handles test_request_string_hostname_array_array operation. // -// POST /test_request_string_ip_array_array -func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_array_array +func (s *Server) handleTestRequestStringHostnameArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_array_array"), + otelogen.OperationID("test_request_string_hostname_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ip_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_hostname_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(), "TestRequestStringHostnameArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56039,11 +56048,11 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPArrayArray", - ID: "test_request_string_ip_array_array", + Name: "TestRequestStringHostnameArrayArray", + ID: "test_request_string_hostname_array_array", } ) - request, close, err := s.decodeTestRequestStringIPArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringHostnameArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56063,16 +56072,16 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPArrayArray", + OperationName: "TestRequestStringHostnameArrayArray", OperationSummary: "", - OperationID: "test_request_string_ip_array_array", + OperationID: "test_request_string_hostname_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]string Params = struct{} Response = *Error ) @@ -56085,12 +56094,12 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIPArrayArray(ctx, request) + response, err = s.h.TestRequestStringHostnameArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIPArrayArray(ctx, request) + response, err = s.h.TestRequestStringHostnameArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -56098,7 +56107,7 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, args return } - if err := encodeTestRequestStringIPArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56107,18 +56116,18 @@ func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, args } } -// handleTestRequestStringIPNullableRequest handles test_request_string_ip_nullable operation. +// handleTestRequestStringHostnameNullableRequest handles test_request_string_hostname_nullable operation. // -// POST /test_request_string_ip_nullable -func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_nullable +func (s *Server) handleTestRequestStringHostnameNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable"), + otelogen.OperationID("test_request_string_hostname_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ip_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_hostname_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56143,11 +56152,11 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPNullable", - ID: "test_request_string_ip_nullable", + Name: "TestRequestStringHostnameNullable", + ID: "test_request_string_hostname_nullable", } ) - request, close, err := s.decodeTestRequestStringIPNullableRequest(r) + request, close, err := s.decodeTestRequestStringHostnameNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56167,16 +56176,16 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPNullable", + OperationName: "TestRequestStringHostnameNullable", OperationSummary: "", - OperationID: "test_request_string_ip_nullable", + OperationID: "test_request_string_hostname_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilIP + Request = OptNilString Params = struct{} Response = *Error ) @@ -56189,12 +56198,12 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIPNullable(ctx, request) + response, err = s.h.TestRequestStringHostnameNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIPNullable(ctx, request) + response, err = s.h.TestRequestStringHostnameNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -56202,7 +56211,7 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, argsEs return } - if err := encodeTestRequestStringIPNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56211,18 +56220,18 @@ func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, argsEs } } -// handleTestRequestStringIPNullableArrayRequest handles test_request_string_ip_nullable_array operation. +// handleTestRequestStringHostnameNullableArrayRequest handles test_request_string_hostname_nullable_array operation. // -// POST /test_request_string_ip_nullable_array -func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_nullable_array +func (s *Server) handleTestRequestStringHostnameNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable_array"), + otelogen.OperationID("test_request_string_hostname_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ip_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_hostname_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringHostnameNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56247,11 +56256,11 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPNullableArray", - ID: "test_request_string_ip_nullable_array", + Name: "TestRequestStringHostnameNullableArray", + ID: "test_request_string_hostname_nullable_array", } ) - request, close, err := s.decodeTestRequestStringIPNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringHostnameNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56271,16 +56280,16 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPNullableArray", + OperationName: "TestRequestStringHostnameNullableArray", OperationSummary: "", - OperationID: "test_request_string_ip_nullable_array", + OperationID: "test_request_string_hostname_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilIP + Request = []NilString Params = struct{} Response = *Error ) @@ -56293,12 +56302,12 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIPNullableArray(ctx, request) + response, err = s.h.TestRequestStringHostnameNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIPNullableArray(ctx, request) + response, err = s.h.TestRequestStringHostnameNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -56306,7 +56315,7 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, a return } - if err := encodeTestRequestStringIPNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56315,18 +56324,18 @@ func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, a } } -// handleTestRequestStringIPNullableArrayArrayRequest handles test_request_string_ip_nullable_array_array operation. +// handleTestRequestStringHostnameNullableArrayArrayRequest handles test_request_string_hostname_nullable_array_array operation. // -// POST /test_request_string_ip_nullable_array_array -func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_hostname_nullable_array_array +func (s *Server) handleTestRequestStringHostnameNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ip_nullable_array_array"), + otelogen.OperationID("test_request_string_hostname_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ip_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_hostname_nullable_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(), "TestRequestStringHostnameNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56351,11 +56360,11 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIPNullableArrayArray", - ID: "test_request_string_ip_nullable_array_array", + Name: "TestRequestStringHostnameNullableArrayArray", + ID: "test_request_string_hostname_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringIPNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringHostnameNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56375,16 +56384,16 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIPNullableArrayArray", + OperationName: "TestRequestStringHostnameNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_ip_nullable_array_array", + OperationID: "test_request_string_hostname_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilIP + Request = [][]NilString Params = struct{} Response = *Error ) @@ -56397,12 +56406,12 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIPNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIPNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringHostnameNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -56410,7 +56419,7 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri return } - if err := encodeTestRequestStringIPNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56419,18 +56428,18 @@ func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]stri } } -// handleTestRequestStringIntRequest handles test_request_string_int operation. +// handleTestRequestStringIPRequest handles test_request_string_ip operation. // -// POST /test_request_string_int -func (s *Server) handleTestRequestStringIntRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip +func (s *Server) handleTestRequestStringIPRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int"), + otelogen.OperationID("test_request_string_ip"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int"), + semconv.HTTPRouteKey.String("/test_request_string_ip"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIP", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56455,11 +56464,11 @@ func (s *Server) handleTestRequestStringIntRequest(args [0]string, argsEscaped b } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt", - ID: "test_request_string_int", + Name: "TestRequestStringIP", + ID: "test_request_string_ip", } ) - request, close, err := s.decodeTestRequestStringIntRequest(r) + request, close, err := s.decodeTestRequestStringIPRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56479,16 +56488,16 @@ func (s *Server) handleTestRequestStringIntRequest(args [0]string, argsEscaped b if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt", + OperationName: "TestRequestStringIP", OperationSummary: "", - OperationID: "test_request_string_int", + OperationID: "test_request_string_ip", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringInt + Request = OptIP Params = struct{} Response = *Error ) @@ -56501,12 +56510,12 @@ func (s *Server) handleTestRequestStringIntRequest(args [0]string, argsEscaped b mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt(ctx, request) + response, err = s.h.TestRequestStringIP(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt(ctx, request) + response, err = s.h.TestRequestStringIP(ctx, request) } if err != nil { recordError("Internal", err) @@ -56514,7 +56523,7 @@ func (s *Server) handleTestRequestStringIntRequest(args [0]string, argsEscaped b return } - if err := encodeTestRequestStringIntResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56523,18 +56532,18 @@ func (s *Server) handleTestRequestStringIntRequest(args [0]string, argsEscaped b } } -// handleTestRequestStringInt16Request handles test_request_string_int16 operation. +// handleTestRequestStringIPArrayRequest handles test_request_string_ip_array operation. // -// POST /test_request_string_int16 -func (s *Server) handleTestRequestStringInt16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_array +func (s *Server) handleTestRequestStringIPArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int16"), + otelogen.OperationID("test_request_string_ip_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int16"), + semconv.HTTPRouteKey.String("/test_request_string_ip_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56559,11 +56568,11 @@ func (s *Server) handleTestRequestStringInt16Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt16", - ID: "test_request_string_int16", + Name: "TestRequestStringIPArray", + ID: "test_request_string_ip_array", } ) - request, close, err := s.decodeTestRequestStringInt16Request(r) + request, close, err := s.decodeTestRequestStringIPArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56583,16 +56592,16 @@ func (s *Server) handleTestRequestStringInt16Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt16", + OperationName: "TestRequestStringIPArray", OperationSummary: "", - OperationID: "test_request_string_int16", + OperationID: "test_request_string_ip_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringInt16 + Request = []netip.Addr Params = struct{} Response = *Error ) @@ -56605,12 +56614,12 @@ func (s *Server) handleTestRequestStringInt16Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt16(ctx, request) + response, err = s.h.TestRequestStringIPArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt16(ctx, request) + response, err = s.h.TestRequestStringIPArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -56618,7 +56627,7 @@ func (s *Server) handleTestRequestStringInt16Request(args [0]string, argsEscaped return } - if err := encodeTestRequestStringInt16Response(response, w, span); err != nil { + if err := encodeTestRequestStringIPArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56627,18 +56636,18 @@ func (s *Server) handleTestRequestStringInt16Request(args [0]string, argsEscaped } } -// handleTestRequestStringInt16ArrayRequest handles test_request_string_int16_array operation. +// handleTestRequestStringIPArrayArrayRequest handles test_request_string_ip_array_array operation. // -// POST /test_request_string_int16_array -func (s *Server) handleTestRequestStringInt16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_array_array +func (s *Server) handleTestRequestStringIPArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int16_array"), + otelogen.OperationID("test_request_string_ip_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int16_array"), + semconv.HTTPRouteKey.String("/test_request_string_ip_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56663,11 +56672,11 @@ func (s *Server) handleTestRequestStringInt16ArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt16Array", - ID: "test_request_string_int16_array", + Name: "TestRequestStringIPArrayArray", + ID: "test_request_string_ip_array_array", } ) - request, close, err := s.decodeTestRequestStringInt16ArrayRequest(r) + request, close, err := s.decodeTestRequestStringIPArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56687,16 +56696,16 @@ func (s *Server) handleTestRequestStringInt16ArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt16Array", + OperationName: "TestRequestStringIPArrayArray", OperationSummary: "", - OperationID: "test_request_string_int16_array", + OperationID: "test_request_string_ip_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []int16 + Request = [][]netip.Addr Params = struct{} Response = *Error ) @@ -56709,12 +56718,12 @@ func (s *Server) handleTestRequestStringInt16ArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt16Array(ctx, request) + response, err = s.h.TestRequestStringIPArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt16Array(ctx, request) + response, err = s.h.TestRequestStringIPArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -56722,7 +56731,7 @@ func (s *Server) handleTestRequestStringInt16ArrayRequest(args [0]string, argsEs return } - if err := encodeTestRequestStringInt16ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56731,18 +56740,18 @@ func (s *Server) handleTestRequestStringInt16ArrayRequest(args [0]string, argsEs } } -// handleTestRequestStringInt16ArrayArrayRequest handles test_request_string_int16_array_array operation. +// handleTestRequestStringIPNullableRequest handles test_request_string_ip_nullable operation. // -// POST /test_request_string_int16_array_array -func (s *Server) handleTestRequestStringInt16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_nullable +func (s *Server) handleTestRequestStringIPNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int16_array_array"), + otelogen.OperationID("test_request_string_ip_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int16_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_ip_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56767,11 +56776,11 @@ func (s *Server) handleTestRequestStringInt16ArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt16ArrayArray", - ID: "test_request_string_int16_array_array", + Name: "TestRequestStringIPNullable", + ID: "test_request_string_ip_nullable", } ) - request, close, err := s.decodeTestRequestStringInt16ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIPNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56791,16 +56800,16 @@ func (s *Server) handleTestRequestStringInt16ArrayArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt16ArrayArray", + OperationName: "TestRequestStringIPNullable", OperationSummary: "", - OperationID: "test_request_string_int16_array_array", + OperationID: "test_request_string_ip_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]int16 + Request = OptNilIP Params = struct{} Response = *Error ) @@ -56813,12 +56822,12 @@ func (s *Server) handleTestRequestStringInt16ArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt16ArrayArray(ctx, request) + response, err = s.h.TestRequestStringIPNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt16ArrayArray(ctx, request) + response, err = s.h.TestRequestStringIPNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -56826,7 +56835,7 @@ func (s *Server) handleTestRequestStringInt16ArrayArrayRequest(args [0]string, a return } - if err := encodeTestRequestStringInt16ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56835,18 +56844,18 @@ func (s *Server) handleTestRequestStringInt16ArrayArrayRequest(args [0]string, a } } -// handleTestRequestStringInt16NullableRequest handles test_request_string_int16_nullable operation. +// handleTestRequestStringIPNullableArrayRequest handles test_request_string_ip_nullable_array operation. // -// POST /test_request_string_int16_nullable -func (s *Server) handleTestRequestStringInt16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_nullable_array +func (s *Server) handleTestRequestStringIPNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int16_nullable"), + otelogen.OperationID("test_request_string_ip_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int16_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_ip_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56871,11 +56880,11 @@ func (s *Server) handleTestRequestStringInt16NullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt16Nullable", - ID: "test_request_string_int16_nullable", + Name: "TestRequestStringIPNullableArray", + ID: "test_request_string_ip_nullable_array", } ) - request, close, err := s.decodeTestRequestStringInt16NullableRequest(r) + request, close, err := s.decodeTestRequestStringIPNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56895,16 +56904,16 @@ func (s *Server) handleTestRequestStringInt16NullableRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt16Nullable", + OperationName: "TestRequestStringIPNullableArray", OperationSummary: "", - OperationID: "test_request_string_int16_nullable", + OperationID: "test_request_string_ip_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringInt16 + Request = []NilIP Params = struct{} Response = *Error ) @@ -56917,12 +56926,12 @@ func (s *Server) handleTestRequestStringInt16NullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt16Nullable(ctx, request) + response, err = s.h.TestRequestStringIPNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt16Nullable(ctx, request) + response, err = s.h.TestRequestStringIPNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -56930,7 +56939,7 @@ func (s *Server) handleTestRequestStringInt16NullableRequest(args [0]string, arg return } - if err := encodeTestRequestStringInt16NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -56939,18 +56948,18 @@ func (s *Server) handleTestRequestStringInt16NullableRequest(args [0]string, arg } } -// handleTestRequestStringInt16NullableArrayRequest handles test_request_string_int16_nullable_array operation. +// handleTestRequestStringIPNullableArrayArrayRequest handles test_request_string_ip_nullable_array_array operation. // -// POST /test_request_string_int16_nullable_array -func (s *Server) handleTestRequestStringInt16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ip_nullable_array_array +func (s *Server) handleTestRequestStringIPNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int16_nullable_array"), + otelogen.OperationID("test_request_string_ip_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int16_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_ip_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIPNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -56975,11 +56984,11 @@ func (s *Server) handleTestRequestStringInt16NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt16NullableArray", - ID: "test_request_string_int16_nullable_array", + Name: "TestRequestStringIPNullableArrayArray", + ID: "test_request_string_ip_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringInt16NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringIPNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -56999,16 +57008,16 @@ func (s *Server) handleTestRequestStringInt16NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt16NullableArray", + OperationName: "TestRequestStringIPNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_int16_nullable_array", + OperationID: "test_request_string_ip_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringInt16 + Request = [][]NilIP Params = struct{} Response = *Error ) @@ -57021,12 +57030,12 @@ func (s *Server) handleTestRequestStringInt16NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt16NullableArray(ctx, request) + response, err = s.h.TestRequestStringIPNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt16NullableArray(ctx, request) + response, err = s.h.TestRequestStringIPNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -57034,7 +57043,7 @@ func (s *Server) handleTestRequestStringInt16NullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringInt16NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIPNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57043,18 +57052,18 @@ func (s *Server) handleTestRequestStringInt16NullableArrayRequest(args [0]string } } -// handleTestRequestStringInt16NullableArrayArrayRequest handles test_request_string_int16_nullable_array_array operation. +// handleTestRequestStringIntRequest handles test_request_string_int operation. // -// POST /test_request_string_int16_nullable_array_array -func (s *Server) handleTestRequestStringInt16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int +func (s *Server) handleTestRequestStringIntRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int16_nullable_array_array"), + otelogen.OperationID("test_request_string_int"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int16_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57079,11 +57088,11 @@ func (s *Server) handleTestRequestStringInt16NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt16NullableArrayArray", - ID: "test_request_string_int16_nullable_array_array", + Name: "TestRequestStringInt", + ID: "test_request_string_int", } ) - request, close, err := s.decodeTestRequestStringInt16NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIntRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57103,16 +57112,16 @@ func (s *Server) handleTestRequestStringInt16NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt16NullableArrayArray", + OperationName: "TestRequestStringInt", OperationSummary: "", - OperationID: "test_request_string_int16_nullable_array_array", + OperationID: "test_request_string_int", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringInt16 + Request = OptStringInt Params = struct{} Response = *Error ) @@ -57125,12 +57134,12 @@ func (s *Server) handleTestRequestStringInt16NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt16NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt16NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt(ctx, request) } if err != nil { recordError("Internal", err) @@ -57138,7 +57147,7 @@ func (s *Server) handleTestRequestStringInt16NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringInt16NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIntResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57147,18 +57156,18 @@ func (s *Server) handleTestRequestStringInt16NullableArrayArrayRequest(args [0]s } } -// handleTestRequestStringInt32Request handles test_request_string_int32 operation. +// handleTestRequestStringInt16Request handles test_request_string_int16 operation. // -// POST /test_request_string_int32 -func (s *Server) handleTestRequestStringInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int16 +func (s *Server) handleTestRequestStringInt16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32"), + otelogen.OperationID("test_request_string_int16"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int32"), + semconv.HTTPRouteKey.String("/test_request_string_int16"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57183,11 +57192,11 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32", - ID: "test_request_string_int32", + Name: "TestRequestStringInt16", + ID: "test_request_string_int16", } ) - request, close, err := s.decodeTestRequestStringInt32Request(r) + request, close, err := s.decodeTestRequestStringInt16Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57207,16 +57216,16 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32", + OperationName: "TestRequestStringInt16", OperationSummary: "", - OperationID: "test_request_string_int32", + OperationID: "test_request_string_int16", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringInt32 + Request = OptStringInt16 Params = struct{} Response = *Error ) @@ -57229,12 +57238,12 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt32(ctx, request) + response, err = s.h.TestRequestStringInt16(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt32(ctx, request) + response, err = s.h.TestRequestStringInt16(ctx, request) } if err != nil { recordError("Internal", err) @@ -57242,7 +57251,7 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, argsEscaped return } - if err := encodeTestRequestStringInt32Response(response, w, span); err != nil { + if err := encodeTestRequestStringInt16Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57251,18 +57260,18 @@ func (s *Server) handleTestRequestStringInt32Request(args [0]string, argsEscaped } } -// handleTestRequestStringInt32ArrayRequest handles test_request_string_int32_array operation. +// handleTestRequestStringInt16ArrayRequest handles test_request_string_int16_array operation. // -// POST /test_request_string_int32_array -func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int16_array +func (s *Server) handleTestRequestStringInt16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_array"), + otelogen.OperationID("test_request_string_int16_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int32_array"), + semconv.HTTPRouteKey.String("/test_request_string_int16_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57287,11 +57296,11 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32Array", - ID: "test_request_string_int32_array", + Name: "TestRequestStringInt16Array", + ID: "test_request_string_int16_array", } ) - request, close, err := s.decodeTestRequestStringInt32ArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt16ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57311,16 +57320,16 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32Array", + OperationName: "TestRequestStringInt16Array", OperationSummary: "", - OperationID: "test_request_string_int32_array", + OperationID: "test_request_string_int16_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []int32 + Request = []int16 Params = struct{} Response = *Error ) @@ -57333,12 +57342,12 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt32Array(ctx, request) + response, err = s.h.TestRequestStringInt16Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt32Array(ctx, request) + response, err = s.h.TestRequestStringInt16Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -57346,7 +57355,7 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, argsEs return } - if err := encodeTestRequestStringInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt16ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57355,18 +57364,18 @@ func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, argsEs } } -// handleTestRequestStringInt32ArrayArrayRequest handles test_request_string_int32_array_array operation. +// handleTestRequestStringInt16ArrayArrayRequest handles test_request_string_int16_array_array operation. // -// POST /test_request_string_int32_array_array -func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int16_array_array +func (s *Server) handleTestRequestStringInt16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_array_array"), + otelogen.OperationID("test_request_string_int16_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int32_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int16_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(), "TestRequestStringInt16ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57391,11 +57400,11 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32ArrayArray", - ID: "test_request_string_int32_array_array", + Name: "TestRequestStringInt16ArrayArray", + ID: "test_request_string_int16_array_array", } ) - request, close, err := s.decodeTestRequestStringInt32ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt16ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57415,16 +57424,16 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32ArrayArray", + OperationName: "TestRequestStringInt16ArrayArray", OperationSummary: "", - OperationID: "test_request_string_int32_array_array", + OperationID: "test_request_string_int16_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]int32 + Request = [][]int16 Params = struct{} Response = *Error ) @@ -57437,12 +57446,12 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt32ArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt16ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt32ArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt16ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -57450,7 +57459,7 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, a return } - if err := encodeTestRequestStringInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt16ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57459,18 +57468,18 @@ func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, a } } -// handleTestRequestStringInt32NullableRequest handles test_request_string_int32_nullable operation. +// handleTestRequestStringInt16NullableRequest handles test_request_string_int16_nullable operation. // -// POST /test_request_string_int32_nullable -func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int16_nullable +func (s *Server) handleTestRequestStringInt16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable"), + otelogen.OperationID("test_request_string_int16_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int32_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_int16_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57495,11 +57504,11 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32Nullable", - ID: "test_request_string_int32_nullable", + Name: "TestRequestStringInt16Nullable", + ID: "test_request_string_int16_nullable", } ) - request, close, err := s.decodeTestRequestStringInt32NullableRequest(r) + request, close, err := s.decodeTestRequestStringInt16NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57519,16 +57528,16 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32Nullable", + OperationName: "TestRequestStringInt16Nullable", OperationSummary: "", - OperationID: "test_request_string_int32_nullable", + OperationID: "test_request_string_int16_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringInt32 + Request = OptNilStringInt16 Params = struct{} Response = *Error ) @@ -57541,12 +57550,12 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt32Nullable(ctx, request) + response, err = s.h.TestRequestStringInt16Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt32Nullable(ctx, request) + response, err = s.h.TestRequestStringInt16Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -57554,7 +57563,7 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, arg return } - if err := encodeTestRequestStringInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt16NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57563,18 +57572,18 @@ func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, arg } } -// handleTestRequestStringInt32NullableArrayRequest handles test_request_string_int32_nullable_array operation. +// handleTestRequestStringInt16NullableArrayRequest handles test_request_string_int16_nullable_array operation. // -// POST /test_request_string_int32_nullable_array -func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int16_nullable_array +func (s *Server) handleTestRequestStringInt16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable_array"), + otelogen.OperationID("test_request_string_int16_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int32_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_int16_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt16NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57599,11 +57608,11 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32NullableArray", - ID: "test_request_string_int32_nullable_array", + Name: "TestRequestStringInt16NullableArray", + ID: "test_request_string_int16_nullable_array", } ) - request, close, err := s.decodeTestRequestStringInt32NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt16NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57623,16 +57632,16 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32NullableArray", + OperationName: "TestRequestStringInt16NullableArray", OperationSummary: "", - OperationID: "test_request_string_int32_nullable_array", + OperationID: "test_request_string_int16_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringInt32 + Request = []NilStringInt16 Params = struct{} Response = *Error ) @@ -57645,12 +57654,12 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt32NullableArray(ctx, request) + response, err = s.h.TestRequestStringInt16NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt32NullableArray(ctx, request) + response, err = s.h.TestRequestStringInt16NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -57658,7 +57667,7 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt16NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57667,18 +57676,18 @@ func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string } } -// handleTestRequestStringInt32NullableArrayArrayRequest handles test_request_string_int32_nullable_array_array operation. +// handleTestRequestStringInt16NullableArrayArrayRequest handles test_request_string_int16_nullable_array_array operation. // -// POST /test_request_string_int32_nullable_array_array -func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int16_nullable_array_array +func (s *Server) handleTestRequestStringInt16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int32_nullable_array_array"), + otelogen.OperationID("test_request_string_int16_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int16_nullable_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(), "TestRequestStringInt16NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57703,11 +57712,11 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt32NullableArrayArray", - ID: "test_request_string_int32_nullable_array_array", + Name: "TestRequestStringInt16NullableArrayArray", + ID: "test_request_string_int16_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringInt32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt16NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57727,16 +57736,16 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt32NullableArrayArray", + OperationName: "TestRequestStringInt16NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_int32_nullable_array_array", + OperationID: "test_request_string_int16_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringInt32 + Request = [][]NilStringInt16 Params = struct{} Response = *Error ) @@ -57749,12 +57758,12 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt16NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt16NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -57762,7 +57771,7 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt16NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57771,18 +57780,18 @@ func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]s } } -// handleTestRequestStringInt64Request handles test_request_string_int64 operation. +// handleTestRequestStringInt32Request handles test_request_string_int32 operation. // -// POST /test_request_string_int64 -func (s *Server) handleTestRequestStringInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32 +func (s *Server) handleTestRequestStringInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64"), + otelogen.OperationID("test_request_string_int32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int64"), + semconv.HTTPRouteKey.String("/test_request_string_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57807,11 +57816,11 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64", - ID: "test_request_string_int64", + Name: "TestRequestStringInt32", + ID: "test_request_string_int32", } ) - request, close, err := s.decodeTestRequestStringInt64Request(r) + request, close, err := s.decodeTestRequestStringInt32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57831,16 +57840,16 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64", + OperationName: "TestRequestStringInt32", OperationSummary: "", - OperationID: "test_request_string_int64", + OperationID: "test_request_string_int32", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringInt64 + Request = OptStringInt32 Params = struct{} Response = *Error ) @@ -57853,12 +57862,12 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt64(ctx, request) + response, err = s.h.TestRequestStringInt32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt64(ctx, request) + response, err = s.h.TestRequestStringInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -57866,7 +57875,7 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, argsEscaped return } - if err := encodeTestRequestStringInt64Response(response, w, span); err != nil { + if err := encodeTestRequestStringInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57875,18 +57884,18 @@ func (s *Server) handleTestRequestStringInt64Request(args [0]string, argsEscaped } } -// handleTestRequestStringInt64ArrayRequest handles test_request_string_int64_array operation. +// handleTestRequestStringInt32ArrayRequest handles test_request_string_int32_array operation. // -// POST /test_request_string_int64_array -func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_array +func (s *Server) handleTestRequestStringInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_array"), + otelogen.OperationID("test_request_string_int32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int64_array"), + semconv.HTTPRouteKey.String("/test_request_string_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -57911,11 +57920,11 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64Array", - ID: "test_request_string_int64_array", + Name: "TestRequestStringInt32Array", + ID: "test_request_string_int32_array", } ) - request, close, err := s.decodeTestRequestStringInt64ArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -57935,16 +57944,16 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64Array", + OperationName: "TestRequestStringInt32Array", OperationSummary: "", - OperationID: "test_request_string_int64_array", + OperationID: "test_request_string_int32_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []int64 + Request = []int32 Params = struct{} Response = *Error ) @@ -57957,12 +57966,12 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt64Array(ctx, request) + response, err = s.h.TestRequestStringInt32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt64Array(ctx, request) + response, err = s.h.TestRequestStringInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -57970,7 +57979,7 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, argsEs return } - if err := encodeTestRequestStringInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -57979,18 +57988,18 @@ func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, argsEs } } -// handleTestRequestStringInt64ArrayArrayRequest handles test_request_string_int64_array_array operation. +// handleTestRequestStringInt32ArrayArrayRequest handles test_request_string_int32_array_array operation. // -// POST /test_request_string_int64_array_array -func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_array_array +func (s *Server) handleTestRequestStringInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_array_array"), + otelogen.OperationID("test_request_string_int32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int64_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int32_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(), "TestRequestStringInt32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58015,11 +58024,11 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64ArrayArray", - ID: "test_request_string_int64_array_array", + Name: "TestRequestStringInt32ArrayArray", + ID: "test_request_string_int32_array_array", } ) - request, close, err := s.decodeTestRequestStringInt64ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58039,16 +58048,16 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64ArrayArray", + OperationName: "TestRequestStringInt32ArrayArray", OperationSummary: "", - OperationID: "test_request_string_int64_array_array", + OperationID: "test_request_string_int32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]int64 + Request = [][]int32 Params = struct{} Response = *Error ) @@ -58061,12 +58070,12 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt64ArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt64ArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -58074,7 +58083,7 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, a return } - if err := encodeTestRequestStringInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58083,18 +58092,18 @@ func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, a } } -// handleTestRequestStringInt64NullableRequest handles test_request_string_int64_nullable operation. +// handleTestRequestStringInt32NullableRequest handles test_request_string_int32_nullable operation. // -// POST /test_request_string_int64_nullable -func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_nullable +func (s *Server) handleTestRequestStringInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable"), + otelogen.OperationID("test_request_string_int32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int64_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58119,11 +58128,11 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64Nullable", - ID: "test_request_string_int64_nullable", + Name: "TestRequestStringInt32Nullable", + ID: "test_request_string_int32_nullable", } ) - request, close, err := s.decodeTestRequestStringInt64NullableRequest(r) + request, close, err := s.decodeTestRequestStringInt32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58143,16 +58152,16 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64Nullable", + OperationName: "TestRequestStringInt32Nullable", OperationSummary: "", - OperationID: "test_request_string_int64_nullable", + OperationID: "test_request_string_int32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringInt64 + Request = OptNilStringInt32 Params = struct{} Response = *Error ) @@ -58165,12 +58174,12 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt64Nullable(ctx, request) + response, err = s.h.TestRequestStringInt32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt64Nullable(ctx, request) + response, err = s.h.TestRequestStringInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -58178,7 +58187,7 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, arg return } - if err := encodeTestRequestStringInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58187,18 +58196,18 @@ func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, arg } } -// handleTestRequestStringInt64NullableArrayRequest handles test_request_string_int64_nullable_array operation. +// handleTestRequestStringInt32NullableArrayRequest handles test_request_string_int32_nullable_array operation. // -// POST /test_request_string_int64_nullable_array -func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_nullable_array +func (s *Server) handleTestRequestStringInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable_array"), + otelogen.OperationID("test_request_string_int32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int64_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58223,11 +58232,11 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64NullableArray", - ID: "test_request_string_int64_nullable_array", + Name: "TestRequestStringInt32NullableArray", + ID: "test_request_string_int32_nullable_array", } ) - request, close, err := s.decodeTestRequestStringInt64NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58247,16 +58256,16 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64NullableArray", + OperationName: "TestRequestStringInt32NullableArray", OperationSummary: "", - OperationID: "test_request_string_int64_nullable_array", + OperationID: "test_request_string_int32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringInt64 + Request = []NilStringInt32 Params = struct{} Response = *Error ) @@ -58269,12 +58278,12 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt64NullableArray(ctx, request) + response, err = s.h.TestRequestStringInt32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt64NullableArray(ctx, request) + response, err = s.h.TestRequestStringInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -58282,7 +58291,7 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58291,18 +58300,18 @@ func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string } } -// handleTestRequestStringInt64NullableArrayArrayRequest handles test_request_string_int64_nullable_array_array operation. +// handleTestRequestStringInt32NullableArrayArrayRequest handles test_request_string_int32_nullable_array_array operation. // -// POST /test_request_string_int64_nullable_array_array -func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int32_nullable_array_array +func (s *Server) handleTestRequestStringInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int64_nullable_array_array"), + otelogen.OperationID("test_request_string_int32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int32_nullable_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(), "TestRequestStringInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58327,11 +58336,11 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt64NullableArrayArray", - ID: "test_request_string_int64_nullable_array_array", + Name: "TestRequestStringInt32NullableArrayArray", + ID: "test_request_string_int32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringInt64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58351,16 +58360,16 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt64NullableArrayArray", + OperationName: "TestRequestStringInt32NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_int64_nullable_array_array", + OperationID: "test_request_string_int32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringInt64 + Request = [][]NilStringInt32 Params = struct{} Response = *Error ) @@ -58373,12 +58382,12 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -58386,7 +58395,7 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58395,18 +58404,18 @@ func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]s } } -// handleTestRequestStringInt8Request handles test_request_string_int8 operation. +// handleTestRequestStringInt64Request handles test_request_string_int64 operation. // -// POST /test_request_string_int8 -func (s *Server) handleTestRequestStringInt8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64 +func (s *Server) handleTestRequestStringInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int8"), + otelogen.OperationID("test_request_string_int64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int8"), + semconv.HTTPRouteKey.String("/test_request_string_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58431,11 +58440,11 @@ func (s *Server) handleTestRequestStringInt8Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt8", - ID: "test_request_string_int8", + Name: "TestRequestStringInt64", + ID: "test_request_string_int64", } ) - request, close, err := s.decodeTestRequestStringInt8Request(r) + request, close, err := s.decodeTestRequestStringInt64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58455,16 +58464,16 @@ func (s *Server) handleTestRequestStringInt8Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt8", + OperationName: "TestRequestStringInt64", OperationSummary: "", - OperationID: "test_request_string_int8", + OperationID: "test_request_string_int64", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringInt8 + Request = OptStringInt64 Params = struct{} Response = *Error ) @@ -58477,12 +58486,12 @@ func (s *Server) handleTestRequestStringInt8Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt8(ctx, request) + response, err = s.h.TestRequestStringInt64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt8(ctx, request) + response, err = s.h.TestRequestStringInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -58490,7 +58499,7 @@ func (s *Server) handleTestRequestStringInt8Request(args [0]string, argsEscaped return } - if err := encodeTestRequestStringInt8Response(response, w, span); err != nil { + if err := encodeTestRequestStringInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58499,18 +58508,18 @@ func (s *Server) handleTestRequestStringInt8Request(args [0]string, argsEscaped } } -// handleTestRequestStringInt8ArrayRequest handles test_request_string_int8_array operation. +// handleTestRequestStringInt64ArrayRequest handles test_request_string_int64_array operation. // -// POST /test_request_string_int8_array -func (s *Server) handleTestRequestStringInt8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_array +func (s *Server) handleTestRequestStringInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int8_array"), + otelogen.OperationID("test_request_string_int64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int8_array"), + semconv.HTTPRouteKey.String("/test_request_string_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58535,11 +58544,11 @@ func (s *Server) handleTestRequestStringInt8ArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt8Array", - ID: "test_request_string_int8_array", + Name: "TestRequestStringInt64Array", + ID: "test_request_string_int64_array", } ) - request, close, err := s.decodeTestRequestStringInt8ArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58559,16 +58568,16 @@ func (s *Server) handleTestRequestStringInt8ArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt8Array", + OperationName: "TestRequestStringInt64Array", OperationSummary: "", - OperationID: "test_request_string_int8_array", + OperationID: "test_request_string_int64_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []int8 + Request = []int64 Params = struct{} Response = *Error ) @@ -58581,12 +58590,12 @@ func (s *Server) handleTestRequestStringInt8ArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt8Array(ctx, request) + response, err = s.h.TestRequestStringInt64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt8Array(ctx, request) + response, err = s.h.TestRequestStringInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -58594,7 +58603,7 @@ func (s *Server) handleTestRequestStringInt8ArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringInt8ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58603,18 +58612,18 @@ func (s *Server) handleTestRequestStringInt8ArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringInt8ArrayArrayRequest handles test_request_string_int8_array_array operation. +// handleTestRequestStringInt64ArrayArrayRequest handles test_request_string_int64_array_array operation. // -// POST /test_request_string_int8_array_array -func (s *Server) handleTestRequestStringInt8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_array_array +func (s *Server) handleTestRequestStringInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int8_array_array"), + otelogen.OperationID("test_request_string_int64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int8_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58639,11 +58648,11 @@ func (s *Server) handleTestRequestStringInt8ArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt8ArrayArray", - ID: "test_request_string_int8_array_array", + Name: "TestRequestStringInt64ArrayArray", + ID: "test_request_string_int64_array_array", } ) - request, close, err := s.decodeTestRequestStringInt8ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58663,16 +58672,16 @@ func (s *Server) handleTestRequestStringInt8ArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt8ArrayArray", + OperationName: "TestRequestStringInt64ArrayArray", OperationSummary: "", - OperationID: "test_request_string_int8_array_array", + OperationID: "test_request_string_int64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]int8 + Request = [][]int64 Params = struct{} Response = *Error ) @@ -58685,12 +58694,12 @@ func (s *Server) handleTestRequestStringInt8ArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt8ArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt8ArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -58698,7 +58707,7 @@ func (s *Server) handleTestRequestStringInt8ArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringInt8ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58707,18 +58716,18 @@ func (s *Server) handleTestRequestStringInt8ArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringInt8NullableRequest handles test_request_string_int8_nullable operation. +// handleTestRequestStringInt64NullableRequest handles test_request_string_int64_nullable operation. // -// POST /test_request_string_int8_nullable -func (s *Server) handleTestRequestStringInt8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_nullable +func (s *Server) handleTestRequestStringInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int8_nullable"), + otelogen.OperationID("test_request_string_int64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int8_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58743,11 +58752,11 @@ func (s *Server) handleTestRequestStringInt8NullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt8Nullable", - ID: "test_request_string_int8_nullable", + Name: "TestRequestStringInt64Nullable", + ID: "test_request_string_int64_nullable", } ) - request, close, err := s.decodeTestRequestStringInt8NullableRequest(r) + request, close, err := s.decodeTestRequestStringInt64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58767,16 +58776,16 @@ func (s *Server) handleTestRequestStringInt8NullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt8Nullable", + OperationName: "TestRequestStringInt64Nullable", OperationSummary: "", - OperationID: "test_request_string_int8_nullable", + OperationID: "test_request_string_int64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringInt8 + Request = OptNilStringInt64 Params = struct{} Response = *Error ) @@ -58789,12 +58798,12 @@ func (s *Server) handleTestRequestStringInt8NullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt8Nullable(ctx, request) + response, err = s.h.TestRequestStringInt64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt8Nullable(ctx, request) + response, err = s.h.TestRequestStringInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -58802,7 +58811,7 @@ func (s *Server) handleTestRequestStringInt8NullableRequest(args [0]string, args return } - if err := encodeTestRequestStringInt8NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58811,18 +58820,18 @@ func (s *Server) handleTestRequestStringInt8NullableRequest(args [0]string, args } } -// handleTestRequestStringInt8NullableArrayRequest handles test_request_string_int8_nullable_array operation. +// handleTestRequestStringInt64NullableArrayRequest handles test_request_string_int64_nullable_array operation. // -// POST /test_request_string_int8_nullable_array -func (s *Server) handleTestRequestStringInt8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_nullable_array +func (s *Server) handleTestRequestStringInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int8_nullable_array"), + otelogen.OperationID("test_request_string_int64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int8_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58847,11 +58856,11 @@ func (s *Server) handleTestRequestStringInt8NullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt8NullableArray", - ID: "test_request_string_int8_nullable_array", + Name: "TestRequestStringInt64NullableArray", + ID: "test_request_string_int64_nullable_array", } ) - request, close, err := s.decodeTestRequestStringInt8NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58871,16 +58880,16 @@ func (s *Server) handleTestRequestStringInt8NullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt8NullableArray", + OperationName: "TestRequestStringInt64NullableArray", OperationSummary: "", - OperationID: "test_request_string_int8_nullable_array", + OperationID: "test_request_string_int64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringInt8 + Request = []NilStringInt64 Params = struct{} Response = *Error ) @@ -58893,12 +58902,12 @@ func (s *Server) handleTestRequestStringInt8NullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt8NullableArray(ctx, request) + response, err = s.h.TestRequestStringInt64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt8NullableArray(ctx, request) + response, err = s.h.TestRequestStringInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -58906,7 +58915,7 @@ func (s *Server) handleTestRequestStringInt8NullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringInt8NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -58915,18 +58924,18 @@ func (s *Server) handleTestRequestStringInt8NullableArrayRequest(args [0]string, } } -// handleTestRequestStringInt8NullableArrayArrayRequest handles test_request_string_int8_nullable_array_array operation. +// handleTestRequestStringInt64NullableArrayArrayRequest handles test_request_string_int64_nullable_array_array operation. // -// POST /test_request_string_int8_nullable_array_array -func (s *Server) handleTestRequestStringInt8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int64_nullable_array_array +func (s *Server) handleTestRequestStringInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int8_nullable_array_array"), + otelogen.OperationID("test_request_string_int64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int8_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -58951,11 +58960,11 @@ func (s *Server) handleTestRequestStringInt8NullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringInt8NullableArrayArray", - ID: "test_request_string_int8_nullable_array_array", + Name: "TestRequestStringInt64NullableArrayArray", + ID: "test_request_string_int64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringInt8NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -58975,16 +58984,16 @@ func (s *Server) handleTestRequestStringInt8NullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringInt8NullableArrayArray", + OperationName: "TestRequestStringInt64NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_int8_nullable_array_array", + OperationID: "test_request_string_int64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringInt8 + Request = [][]NilStringInt64 Params = struct{} Response = *Error ) @@ -58997,12 +59006,12 @@ func (s *Server) handleTestRequestStringInt8NullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringInt8NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringInt8NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -59010,7 +59019,7 @@ func (s *Server) handleTestRequestStringInt8NullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringInt8NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59019,18 +59028,18 @@ func (s *Server) handleTestRequestStringInt8NullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringIntArrayRequest handles test_request_string_int_array operation. +// handleTestRequestStringInt8Request handles test_request_string_int8 operation. // -// POST /test_request_string_int_array -func (s *Server) handleTestRequestStringIntArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int8 +func (s *Server) handleTestRequestStringInt8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int_array"), + otelogen.OperationID("test_request_string_int8"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int_array"), + semconv.HTTPRouteKey.String("/test_request_string_int8"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59055,11 +59064,11 @@ func (s *Server) handleTestRequestStringIntArrayRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIntArray", - ID: "test_request_string_int_array", + Name: "TestRequestStringInt8", + ID: "test_request_string_int8", } ) - request, close, err := s.decodeTestRequestStringIntArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt8Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59079,16 +59088,16 @@ func (s *Server) handleTestRequestStringIntArrayRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIntArray", + OperationName: "TestRequestStringInt8", OperationSummary: "", - OperationID: "test_request_string_int_array", + OperationID: "test_request_string_int8", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []int + Request = OptStringInt8 Params = struct{} Response = *Error ) @@ -59101,12 +59110,12 @@ func (s *Server) handleTestRequestStringIntArrayRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIntArray(ctx, request) + response, err = s.h.TestRequestStringInt8(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIntArray(ctx, request) + response, err = s.h.TestRequestStringInt8(ctx, request) } if err != nil { recordError("Internal", err) @@ -59114,7 +59123,7 @@ func (s *Server) handleTestRequestStringIntArrayRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringIntArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt8Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59123,18 +59132,18 @@ func (s *Server) handleTestRequestStringIntArrayRequest(args [0]string, argsEsca } } -// handleTestRequestStringIntArrayArrayRequest handles test_request_string_int_array_array operation. +// handleTestRequestStringInt8ArrayRequest handles test_request_string_int8_array operation. // -// POST /test_request_string_int_array_array -func (s *Server) handleTestRequestStringIntArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int8_array +func (s *Server) handleTestRequestStringInt8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int_array_array"), + otelogen.OperationID("test_request_string_int8_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int8_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59159,11 +59168,11 @@ func (s *Server) handleTestRequestStringIntArrayArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIntArrayArray", - ID: "test_request_string_int_array_array", + Name: "TestRequestStringInt8Array", + ID: "test_request_string_int8_array", } ) - request, close, err := s.decodeTestRequestStringIntArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt8ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59183,16 +59192,16 @@ func (s *Server) handleTestRequestStringIntArrayArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIntArrayArray", + OperationName: "TestRequestStringInt8Array", OperationSummary: "", - OperationID: "test_request_string_int_array_array", + OperationID: "test_request_string_int8_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]int + Request = []int8 Params = struct{} Response = *Error ) @@ -59205,12 +59214,12 @@ func (s *Server) handleTestRequestStringIntArrayArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIntArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt8Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIntArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt8Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -59218,7 +59227,7 @@ func (s *Server) handleTestRequestStringIntArrayArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringIntArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt8ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59227,18 +59236,18 @@ func (s *Server) handleTestRequestStringIntArrayArrayRequest(args [0]string, arg } } -// handleTestRequestStringIntNullableRequest handles test_request_string_int_nullable operation. +// handleTestRequestStringInt8ArrayArrayRequest handles test_request_string_int8_array_array operation. // -// POST /test_request_string_int_nullable -func (s *Server) handleTestRequestStringIntNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int8_array_array +func (s *Server) handleTestRequestStringInt8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int_nullable"), + otelogen.OperationID("test_request_string_int8_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_int8_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59263,11 +59272,11 @@ func (s *Server) handleTestRequestStringIntNullableRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIntNullable", - ID: "test_request_string_int_nullable", + Name: "TestRequestStringInt8ArrayArray", + ID: "test_request_string_int8_array_array", } ) - request, close, err := s.decodeTestRequestStringIntNullableRequest(r) + request, close, err := s.decodeTestRequestStringInt8ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59287,16 +59296,16 @@ func (s *Server) handleTestRequestStringIntNullableRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIntNullable", + OperationName: "TestRequestStringInt8ArrayArray", OperationSummary: "", - OperationID: "test_request_string_int_nullable", + OperationID: "test_request_string_int8_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringInt + Request = [][]int8 Params = struct{} Response = *Error ) @@ -59309,12 +59318,12 @@ func (s *Server) handleTestRequestStringIntNullableRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIntNullable(ctx, request) + response, err = s.h.TestRequestStringInt8ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIntNullable(ctx, request) + response, err = s.h.TestRequestStringInt8ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -59322,7 +59331,7 @@ func (s *Server) handleTestRequestStringIntNullableRequest(args [0]string, argsE return } - if err := encodeTestRequestStringIntNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt8ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59331,18 +59340,18 @@ func (s *Server) handleTestRequestStringIntNullableRequest(args [0]string, argsE } } -// handleTestRequestStringIntNullableArrayRequest handles test_request_string_int_nullable_array operation. +// handleTestRequestStringInt8NullableRequest handles test_request_string_int8_nullable operation. // -// POST /test_request_string_int_nullable_array -func (s *Server) handleTestRequestStringIntNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int8_nullable +func (s *Server) handleTestRequestStringInt8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int_nullable_array"), + otelogen.OperationID("test_request_string_int8_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_int8_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59367,11 +59376,11 @@ func (s *Server) handleTestRequestStringIntNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIntNullableArray", - ID: "test_request_string_int_nullable_array", + Name: "TestRequestStringInt8Nullable", + ID: "test_request_string_int8_nullable", } ) - request, close, err := s.decodeTestRequestStringIntNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt8NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59391,16 +59400,16 @@ func (s *Server) handleTestRequestStringIntNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIntNullableArray", + OperationName: "TestRequestStringInt8Nullable", OperationSummary: "", - OperationID: "test_request_string_int_nullable_array", + OperationID: "test_request_string_int8_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringInt + Request = OptNilStringInt8 Params = struct{} Response = *Error ) @@ -59413,12 +59422,12 @@ func (s *Server) handleTestRequestStringIntNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIntNullableArray(ctx, request) + response, err = s.h.TestRequestStringInt8Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIntNullableArray(ctx, request) + response, err = s.h.TestRequestStringInt8Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -59426,7 +59435,7 @@ func (s *Server) handleTestRequestStringIntNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringIntNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt8NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59435,18 +59444,18 @@ func (s *Server) handleTestRequestStringIntNullableArrayRequest(args [0]string, } } -// handleTestRequestStringIntNullableArrayArrayRequest handles test_request_string_int_nullable_array_array operation. +// handleTestRequestStringInt8NullableArrayRequest handles test_request_string_int8_nullable_array operation. // -// POST /test_request_string_int_nullable_array_array -func (s *Server) handleTestRequestStringIntNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int8_nullable_array +func (s *Server) handleTestRequestStringInt8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_int_nullable_array_array"), + otelogen.OperationID("test_request_string_int8_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_int_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int8_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59471,11 +59480,11 @@ func (s *Server) handleTestRequestStringIntNullableArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIntNullableArrayArray", - ID: "test_request_string_int_nullable_array_array", + Name: "TestRequestStringInt8NullableArray", + ID: "test_request_string_int8_nullable_array", } ) - request, close, err := s.decodeTestRequestStringIntNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringInt8NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59495,16 +59504,16 @@ func (s *Server) handleTestRequestStringIntNullableArrayArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIntNullableArrayArray", + OperationName: "TestRequestStringInt8NullableArray", OperationSummary: "", - OperationID: "test_request_string_int_nullable_array_array", + OperationID: "test_request_string_int8_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringInt + Request = []NilStringInt8 Params = struct{} Response = *Error ) @@ -59517,12 +59526,12 @@ func (s *Server) handleTestRequestStringIntNullableArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIntNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt8NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIntNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringInt8NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -59530,7 +59539,7 @@ func (s *Server) handleTestRequestStringIntNullableArrayArrayRequest(args [0]str return } - if err := encodeTestRequestStringIntNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringInt8NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59539,18 +59548,18 @@ func (s *Server) handleTestRequestStringIntNullableArrayArrayRequest(args [0]str } } -// handleTestRequestStringIpv4Request handles test_request_string_ipv4 operation. +// handleTestRequestStringInt8NullableArrayArrayRequest handles test_request_string_int8_nullable_array_array operation. // -// POST /test_request_string_ipv4 -func (s *Server) handleTestRequestStringIpv4Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int8_nullable_array_array +func (s *Server) handleTestRequestStringInt8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4"), + otelogen.OperationID("test_request_string_int8_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv4"), + semconv.HTTPRouteKey.String("/test_request_string_int8_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringInt8NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59575,11 +59584,11 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4", - ID: "test_request_string_ipv4", + Name: "TestRequestStringInt8NullableArrayArray", + ID: "test_request_string_int8_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv4Request(r) + request, close, err := s.decodeTestRequestStringInt8NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59599,16 +59608,16 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4", + OperationName: "TestRequestStringInt8NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_ipv4", + OperationID: "test_request_string_int8_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptIPv4 + Request = [][]NilStringInt8 Params = struct{} Response = *Error ) @@ -59621,12 +59630,12 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv4(ctx, request) + response, err = s.h.TestRequestStringInt8NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv4(ctx, request) + response, err = s.h.TestRequestStringInt8NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -59634,7 +59643,7 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, argsEscaped return } - if err := encodeTestRequestStringIpv4Response(response, w, span); err != nil { + if err := encodeTestRequestStringInt8NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59643,18 +59652,18 @@ func (s *Server) handleTestRequestStringIpv4Request(args [0]string, argsEscaped } } -// handleTestRequestStringIpv4ArrayRequest handles test_request_string_ipv4_array operation. +// handleTestRequestStringIntArrayRequest handles test_request_string_int_array operation. // -// POST /test_request_string_ipv4_array -func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int_array +func (s *Server) handleTestRequestStringIntArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_array"), + otelogen.OperationID("test_request_string_int_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv4_array"), + semconv.HTTPRouteKey.String("/test_request_string_int_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59679,11 +59688,11 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4Array", - ID: "test_request_string_ipv4_array", + Name: "TestRequestStringIntArray", + ID: "test_request_string_int_array", } ) - request, close, err := s.decodeTestRequestStringIpv4ArrayRequest(r) + request, close, err := s.decodeTestRequestStringIntArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59703,16 +59712,16 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4Array", + OperationName: "TestRequestStringIntArray", OperationSummary: "", - OperationID: "test_request_string_ipv4_array", + OperationID: "test_request_string_int_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []netip.Addr + Request = []int Params = struct{} Response = *Error ) @@ -59725,12 +59734,12 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv4Array(ctx, request) + response, err = s.h.TestRequestStringIntArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv4Array(ctx, request) + response, err = s.h.TestRequestStringIntArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -59738,7 +59747,7 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringIpv4ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIntArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59747,18 +59756,18 @@ func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringIpv4ArrayArrayRequest handles test_request_string_ipv4_array_array operation. +// handleTestRequestStringIntArrayArrayRequest handles test_request_string_int_array_array operation. // -// POST /test_request_string_ipv4_array_array -func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int_array_array +func (s *Server) handleTestRequestStringIntArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_array_array"), + otelogen.OperationID("test_request_string_int_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv4_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int_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(), "TestRequestStringIntArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59783,11 +59792,11 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4ArrayArray", - ID: "test_request_string_ipv4_array_array", + Name: "TestRequestStringIntArrayArray", + ID: "test_request_string_int_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv4ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIntArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59807,16 +59816,16 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4ArrayArray", + OperationName: "TestRequestStringIntArrayArray", OperationSummary: "", - OperationID: "test_request_string_ipv4_array_array", + OperationID: "test_request_string_int_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]netip.Addr + Request = [][]int Params = struct{} Response = *Error ) @@ -59829,12 +59838,12 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv4ArrayArray(ctx, request) + response, err = s.h.TestRequestStringIntArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv4ArrayArray(ctx, request) + response, err = s.h.TestRequestStringIntArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -59842,7 +59851,7 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringIpv4ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIntArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59851,18 +59860,18 @@ func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringIpv4NullableRequest handles test_request_string_ipv4_nullable operation. +// handleTestRequestStringIntNullableRequest handles test_request_string_int_nullable operation. // -// POST /test_request_string_ipv4_nullable -func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int_nullable +func (s *Server) handleTestRequestStringIntNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable"), + otelogen.OperationID("test_request_string_int_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv4_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_int_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59887,11 +59896,11 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4Nullable", - ID: "test_request_string_ipv4_nullable", + Name: "TestRequestStringIntNullable", + ID: "test_request_string_int_nullable", } ) - request, close, err := s.decodeTestRequestStringIpv4NullableRequest(r) + request, close, err := s.decodeTestRequestStringIntNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -59911,16 +59920,16 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4Nullable", + OperationName: "TestRequestStringIntNullable", OperationSummary: "", - OperationID: "test_request_string_ipv4_nullable", + OperationID: "test_request_string_int_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilIPv4 + Request = OptNilStringInt Params = struct{} Response = *Error ) @@ -59933,12 +59942,12 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv4Nullable(ctx, request) + response, err = s.h.TestRequestStringIntNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv4Nullable(ctx, request) + response, err = s.h.TestRequestStringIntNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -59946,7 +59955,7 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, args return } - if err := encodeTestRequestStringIpv4NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIntNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -59955,18 +59964,18 @@ func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, args } } -// handleTestRequestStringIpv4NullableArrayRequest handles test_request_string_ipv4_nullable_array operation. +// handleTestRequestStringIntNullableArrayRequest handles test_request_string_int_nullable_array operation. // -// POST /test_request_string_ipv4_nullable_array -func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int_nullable_array +func (s *Server) handleTestRequestStringIntNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable_array"), + otelogen.OperationID("test_request_string_int_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv4_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_int_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIntNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -59991,11 +60000,11 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4NullableArray", - ID: "test_request_string_ipv4_nullable_array", + Name: "TestRequestStringIntNullableArray", + ID: "test_request_string_int_nullable_array", } ) - request, close, err := s.decodeTestRequestStringIpv4NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringIntNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60015,16 +60024,16 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4NullableArray", + OperationName: "TestRequestStringIntNullableArray", OperationSummary: "", - OperationID: "test_request_string_ipv4_nullable_array", + OperationID: "test_request_string_int_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilIPv4 + Request = []NilStringInt Params = struct{} Response = *Error ) @@ -60037,12 +60046,12 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv4NullableArray(ctx, request) + response, err = s.h.TestRequestStringIntNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv4NullableArray(ctx, request) + response, err = s.h.TestRequestStringIntNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -60050,7 +60059,7 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringIpv4NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIntNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60059,18 +60068,18 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, } } -// handleTestRequestStringIpv4NullableArrayArrayRequest handles test_request_string_ipv4_nullable_array_array operation. +// handleTestRequestStringIntNullableArrayArrayRequest handles test_request_string_int_nullable_array_array operation. // -// POST /test_request_string_ipv4_nullable_array_array -func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_int_nullable_array_array +func (s *Server) handleTestRequestStringIntNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv4_nullable_array_array"), + otelogen.OperationID("test_request_string_int_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv4_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_int_nullable_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(), "TestRequestStringIntNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60095,11 +60104,11 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv4NullableArrayArray", - ID: "test_request_string_ipv4_nullable_array_array", + Name: "TestRequestStringIntNullableArrayArray", + ID: "test_request_string_int_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv4NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIntNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60119,16 +60128,16 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv4NullableArrayArray", + OperationName: "TestRequestStringIntNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_ipv4_nullable_array_array", + OperationID: "test_request_string_int_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilIPv4 + Request = [][]NilStringInt Params = struct{} Response = *Error ) @@ -60141,12 +60150,12 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIntNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIntNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -60154,7 +60163,7 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIntNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60163,18 +60172,18 @@ func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringIpv6Request handles test_request_string_ipv6 operation. +// handleTestRequestStringIpv4Request handles test_request_string_ipv4 operation. // -// POST /test_request_string_ipv6 -func (s *Server) handleTestRequestStringIpv6Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4 +func (s *Server) handleTestRequestStringIpv4Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6"), + otelogen.OperationID("test_request_string_ipv4"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv6"), + semconv.HTTPRouteKey.String("/test_request_string_ipv4"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60199,11 +60208,11 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6", - ID: "test_request_string_ipv6", + Name: "TestRequestStringIpv4", + ID: "test_request_string_ipv4", } ) - request, close, err := s.decodeTestRequestStringIpv6Request(r) + request, close, err := s.decodeTestRequestStringIpv4Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60223,16 +60232,16 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6", + OperationName: "TestRequestStringIpv4", OperationSummary: "", - OperationID: "test_request_string_ipv6", + OperationID: "test_request_string_ipv4", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptIPv6 + Request = OptIPv4 Params = struct{} Response = *Error ) @@ -60245,12 +60254,12 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv6(ctx, request) + response, err = s.h.TestRequestStringIpv4(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv6(ctx, request) + response, err = s.h.TestRequestStringIpv4(ctx, request) } if err != nil { recordError("Internal", err) @@ -60258,7 +60267,7 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, argsEscaped return } - if err := encodeTestRequestStringIpv6Response(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60267,18 +60276,18 @@ func (s *Server) handleTestRequestStringIpv6Request(args [0]string, argsEscaped } } -// handleTestRequestStringIpv6ArrayRequest handles test_request_string_ipv6_array operation. +// handleTestRequestStringIpv4ArrayRequest handles test_request_string_ipv4_array operation. // -// POST /test_request_string_ipv6_array -func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_array +func (s *Server) handleTestRequestStringIpv4ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_array"), + otelogen.OperationID("test_request_string_ipv4_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv6_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv4_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60303,11 +60312,11 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6Array", - ID: "test_request_string_ipv6_array", + Name: "TestRequestStringIpv4Array", + ID: "test_request_string_ipv4_array", } ) - request, close, err := s.decodeTestRequestStringIpv6ArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv4ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60327,9 +60336,9 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6Array", + OperationName: "TestRequestStringIpv4Array", OperationSummary: "", - OperationID: "test_request_string_ipv6_array", + OperationID: "test_request_string_ipv4_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -60349,12 +60358,12 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv6Array(ctx, request) + response, err = s.h.TestRequestStringIpv4Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv6Array(ctx, request) + response, err = s.h.TestRequestStringIpv4Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -60362,7 +60371,7 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringIpv6ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60371,18 +60380,18 @@ func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringIpv6ArrayArrayRequest handles test_request_string_ipv6_array_array operation. +// handleTestRequestStringIpv4ArrayArrayRequest handles test_request_string_ipv4_array_array operation. // -// POST /test_request_string_ipv6_array_array -func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_array_array +func (s *Server) handleTestRequestStringIpv4ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_array_array"), + otelogen.OperationID("test_request_string_ipv4_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv6_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv4_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(), "TestRequestStringIpv4ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60407,11 +60416,11 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6ArrayArray", - ID: "test_request_string_ipv6_array_array", + Name: "TestRequestStringIpv4ArrayArray", + ID: "test_request_string_ipv4_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv6ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv4ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60431,9 +60440,9 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6ArrayArray", + OperationName: "TestRequestStringIpv4ArrayArray", OperationSummary: "", - OperationID: "test_request_string_ipv6_array_array", + OperationID: "test_request_string_ipv4_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -60453,12 +60462,12 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv6ArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv4ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv6ArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv4ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -60466,7 +60475,7 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringIpv6ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60475,18 +60484,18 @@ func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringIpv6NullableRequest handles test_request_string_ipv6_nullable operation. +// handleTestRequestStringIpv4NullableRequest handles test_request_string_ipv4_nullable operation. // -// POST /test_request_string_ipv6_nullable -func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_nullable +func (s *Server) handleTestRequestStringIpv4NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable"), + otelogen.OperationID("test_request_string_ipv4_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv6_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_ipv4_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60511,11 +60520,11 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6Nullable", - ID: "test_request_string_ipv6_nullable", + Name: "TestRequestStringIpv4Nullable", + ID: "test_request_string_ipv4_nullable", } ) - request, close, err := s.decodeTestRequestStringIpv6NullableRequest(r) + request, close, err := s.decodeTestRequestStringIpv4NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60535,16 +60544,16 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6Nullable", + OperationName: "TestRequestStringIpv4Nullable", OperationSummary: "", - OperationID: "test_request_string_ipv6_nullable", + OperationID: "test_request_string_ipv4_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilIPv6 + Request = OptNilIPv4 Params = struct{} Response = *Error ) @@ -60557,12 +60566,12 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv6Nullable(ctx, request) + response, err = s.h.TestRequestStringIpv4Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv6Nullable(ctx, request) + response, err = s.h.TestRequestStringIpv4Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -60570,7 +60579,7 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, args return } - if err := encodeTestRequestStringIpv6NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60579,18 +60588,18 @@ func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, args } } -// handleTestRequestStringIpv6NullableArrayRequest handles test_request_string_ipv6_nullable_array operation. +// handleTestRequestStringIpv4NullableArrayRequest handles test_request_string_ipv4_nullable_array operation. // -// POST /test_request_string_ipv6_nullable_array -func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_nullable_array +func (s *Server) handleTestRequestStringIpv4NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable_array"), + otelogen.OperationID("test_request_string_ipv4_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv6_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv4_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv4NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60615,11 +60624,11 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6NullableArray", - ID: "test_request_string_ipv6_nullable_array", + Name: "TestRequestStringIpv4NullableArray", + ID: "test_request_string_ipv4_nullable_array", } ) - request, close, err := s.decodeTestRequestStringIpv6NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv4NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60639,16 +60648,16 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6NullableArray", + OperationName: "TestRequestStringIpv4NullableArray", OperationSummary: "", - OperationID: "test_request_string_ipv6_nullable_array", + OperationID: "test_request_string_ipv4_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilIPv6 + Request = []NilIPv4 Params = struct{} Response = *Error ) @@ -60661,12 +60670,12 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv6NullableArray(ctx, request) + response, err = s.h.TestRequestStringIpv4NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv6NullableArray(ctx, request) + response, err = s.h.TestRequestStringIpv4NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -60674,7 +60683,7 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringIpv6NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60683,18 +60692,18 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, } } -// handleTestRequestStringIpv6NullableArrayArrayRequest handles test_request_string_ipv6_nullable_array_array operation. +// handleTestRequestStringIpv4NullableArrayArrayRequest handles test_request_string_ipv4_nullable_array_array operation. // -// POST /test_request_string_ipv6_nullable_array_array -func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv4_nullable_array_array +func (s *Server) handleTestRequestStringIpv4NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_ipv6_nullable_array_array"), + otelogen.OperationID("test_request_string_ipv4_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_ipv6_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv4_nullable_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(), "TestRequestStringIpv4NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60719,11 +60728,11 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringIpv6NullableArrayArray", - ID: "test_request_string_ipv6_nullable_array_array", + Name: "TestRequestStringIpv4NullableArrayArray", + ID: "test_request_string_ipv4_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringIpv6NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv4NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60743,16 +60752,16 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringIpv6NullableArrayArray", + OperationName: "TestRequestStringIpv4NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_ipv6_nullable_array_array", + OperationID: "test_request_string_ipv4_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilIPv6 + Request = [][]NilIPv4 Params = struct{} Response = *Error ) @@ -60765,12 +60774,12 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv4NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -60778,7 +60787,7 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60787,18 +60796,18 @@ func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringNullableRequest handles test_request_string_nullable operation. +// handleTestRequestStringIpv6Request handles test_request_string_ipv6 operation. // -// POST /test_request_string_nullable -func (s *Server) handleTestRequestStringNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6 +func (s *Server) handleTestRequestStringIpv6Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable"), + otelogen.OperationID("test_request_string_ipv6"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_ipv6"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60823,11 +60832,11 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringNullable", - ID: "test_request_string_nullable", + Name: "TestRequestStringIpv6", + ID: "test_request_string_ipv6", } ) - request, close, err := s.decodeTestRequestStringNullableRequest(r) + request, close, err := s.decodeTestRequestStringIpv6Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60847,16 +60856,16 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringNullable", + OperationName: "TestRequestStringIpv6", OperationSummary: "", - OperationID: "test_request_string_nullable", + OperationID: "test_request_string_ipv6", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilString + Request = OptIPv6 Params = struct{} Response = *Error ) @@ -60869,12 +60878,12 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringNullable(ctx, request) + response, err = s.h.TestRequestStringIpv6(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringNullable(ctx, request) + response, err = s.h.TestRequestStringIpv6(ctx, request) } if err != nil { recordError("Internal", err) @@ -60882,7 +60891,7 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60891,18 +60900,18 @@ func (s *Server) handleTestRequestStringNullableRequest(args [0]string, argsEsca } } -// handleTestRequestStringNullableArrayRequest handles test_request_string_nullable_array operation. +// handleTestRequestStringIpv6ArrayRequest handles test_request_string_ipv6_array operation. // -// POST /test_request_string_nullable_array -func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_array +func (s *Server) handleTestRequestStringIpv6ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable_array"), + otelogen.OperationID("test_request_string_ipv6_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv6_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -60927,11 +60936,11 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringNullableArray", - ID: "test_request_string_nullable_array", + Name: "TestRequestStringIpv6Array", + ID: "test_request_string_ipv6_array", } ) - request, close, err := s.decodeTestRequestStringNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv6ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -60951,16 +60960,16 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringNullableArray", + OperationName: "TestRequestStringIpv6Array", OperationSummary: "", - OperationID: "test_request_string_nullable_array", + OperationID: "test_request_string_ipv6_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilString + Request = []netip.Addr Params = struct{} Response = *Error ) @@ -60973,12 +60982,12 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringNullableArray(ctx, request) + response, err = s.h.TestRequestStringIpv6Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringNullableArray(ctx, request) + response, err = s.h.TestRequestStringIpv6Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -60986,7 +60995,7 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -60995,18 +61004,18 @@ func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, arg } } -// handleTestRequestStringNullableArrayArrayRequest handles test_request_string_nullable_array_array operation. +// handleTestRequestStringIpv6ArrayArrayRequest handles test_request_string_ipv6_array_array operation. // -// POST /test_request_string_nullable_array_array -func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_array_array +func (s *Server) handleTestRequestStringIpv6ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_nullable_array_array"), + otelogen.OperationID("test_request_string_ipv6_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv6_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(), "TestRequestStringIpv6ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61031,11 +61040,11 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringNullableArrayArray", - ID: "test_request_string_nullable_array_array", + Name: "TestRequestStringIpv6ArrayArray", + ID: "test_request_string_ipv6_array_array", } ) - request, close, err := s.decodeTestRequestStringNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv6ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61055,16 +61064,16 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringNullableArrayArray", + OperationName: "TestRequestStringIpv6ArrayArray", OperationSummary: "", - OperationID: "test_request_string_nullable_array_array", + OperationID: "test_request_string_ipv6_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]netip.Addr Params = struct{} Response = *Error ) @@ -61077,12 +61086,12 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv6ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv6ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -61090,7 +61099,7 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61099,18 +61108,18 @@ func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string } } -// handleTestRequestStringPasswordRequest handles test_request_string_password operation. +// handleTestRequestStringIpv6NullableRequest handles test_request_string_ipv6_nullable operation. // -// POST /test_request_string_password -func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_nullable +func (s *Server) handleTestRequestStringIpv6NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password"), + otelogen.OperationID("test_request_string_ipv6_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_password"), + semconv.HTTPRouteKey.String("/test_request_string_ipv6_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPassword", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61135,11 +61144,11 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPassword", - ID: "test_request_string_password", + Name: "TestRequestStringIpv6Nullable", + ID: "test_request_string_ipv6_nullable", } ) - request, close, err := s.decodeTestRequestStringPasswordRequest(r) + request, close, err := s.decodeTestRequestStringIpv6NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61159,16 +61168,16 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPassword", + OperationName: "TestRequestStringIpv6Nullable", OperationSummary: "", - OperationID: "test_request_string_password", + OperationID: "test_request_string_ipv6_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptString + Request = OptNilIPv6 Params = struct{} Response = *Error ) @@ -61181,12 +61190,12 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringPassword(ctx, request) + response, err = s.h.TestRequestStringIpv6Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringPassword(ctx, request) + response, err = s.h.TestRequestStringIpv6Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -61194,7 +61203,7 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringPasswordResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61203,18 +61212,18 @@ func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, argsEsca } } -// handleTestRequestStringPasswordArrayRequest handles test_request_string_password_array operation. +// handleTestRequestStringIpv6NullableArrayRequest handles test_request_string_ipv6_nullable_array operation. // -// POST /test_request_string_password_array -func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_nullable_array +func (s *Server) handleTestRequestStringIpv6NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_array"), + otelogen.OperationID("test_request_string_ipv6_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_password_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv6_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringIpv6NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61239,11 +61248,11 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordArray", - ID: "test_request_string_password_array", + Name: "TestRequestStringIpv6NullableArray", + ID: "test_request_string_ipv6_nullable_array", } ) - request, close, err := s.decodeTestRequestStringPasswordArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv6NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61263,16 +61272,16 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordArray", + OperationName: "TestRequestStringIpv6NullableArray", OperationSummary: "", - OperationID: "test_request_string_password_array", + OperationID: "test_request_string_ipv6_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []string + Request = []NilIPv6 Params = struct{} Response = *Error ) @@ -61285,12 +61294,12 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringPasswordArray(ctx, request) + response, err = s.h.TestRequestStringIpv6NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringPasswordArray(ctx, request) + response, err = s.h.TestRequestStringIpv6NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -61298,7 +61307,7 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringPasswordArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61307,18 +61316,18 @@ func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, arg } } -// handleTestRequestStringPasswordArrayArrayRequest handles test_request_string_password_array_array operation. +// handleTestRequestStringIpv6NullableArrayArrayRequest handles test_request_string_ipv6_nullable_array_array operation. // -// POST /test_request_string_password_array_array -func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_ipv6_nullable_array_array +func (s *Server) handleTestRequestStringIpv6NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_array_array"), + otelogen.OperationID("test_request_string_ipv6_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_password_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_ipv6_nullable_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(), "TestRequestStringIpv6NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61343,11 +61352,11 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordArrayArray", - ID: "test_request_string_password_array_array", + Name: "TestRequestStringIpv6NullableArrayArray", + ID: "test_request_string_ipv6_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringPasswordArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringIpv6NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61367,16 +61376,16 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordArrayArray", + OperationName: "TestRequestStringIpv6NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_password_array_array", + OperationID: "test_request_string_ipv6_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]string + Request = [][]NilIPv6 Params = struct{} Response = *Error ) @@ -61389,12 +61398,12 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringPasswordArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringPasswordArrayArray(ctx, request) + response, err = s.h.TestRequestStringIpv6NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -61402,7 +61411,7 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringPasswordArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61411,18 +61420,18 @@ func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string } } -// handleTestRequestStringPasswordNullableRequest handles test_request_string_password_nullable operation. +// handleTestRequestStringMACRequest handles test_request_string_mac operation. // -// POST /test_request_string_password_nullable -func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_mac +func (s *Server) handleTestRequestStringMACRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable"), + otelogen.OperationID("test_request_string_mac"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_password_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_mac"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringMAC", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61447,11 +61456,11 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordNullable", - ID: "test_request_string_password_nullable", + Name: "TestRequestStringMAC", + ID: "test_request_string_mac", } ) - request, close, err := s.decodeTestRequestStringPasswordNullableRequest(r) + request, close, err := s.decodeTestRequestStringMACRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61471,16 +61480,16 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordNullable", + OperationName: "TestRequestStringMAC", OperationSummary: "", - OperationID: "test_request_string_password_nullable", + OperationID: "test_request_string_mac", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilString + Request = OptHardwareAddr Params = struct{} Response = *Error ) @@ -61493,12 +61502,12 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringPasswordNullable(ctx, request) + response, err = s.h.TestRequestStringMAC(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringPasswordNullable(ctx, request) + response, err = s.h.TestRequestStringMAC(ctx, request) } if err != nil { recordError("Internal", err) @@ -61506,7 +61515,7 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, return } - if err := encodeTestRequestStringPasswordNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringMACResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61515,18 +61524,18 @@ func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, } } -// handleTestRequestStringPasswordNullableArrayRequest handles test_request_string_password_nullable_array operation. +// handleTestRequestStringMACArrayRequest handles test_request_string_mac_array operation. // -// POST /test_request_string_password_nullable_array -func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_mac_array +func (s *Server) handleTestRequestStringMACArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable_array"), + otelogen.OperationID("test_request_string_mac_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_password_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_mac_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringMACArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61551,11 +61560,11 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordNullableArray", - ID: "test_request_string_password_nullable_array", + Name: "TestRequestStringMACArray", + ID: "test_request_string_mac_array", } ) - request, close, err := s.decodeTestRequestStringPasswordNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringMACArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61575,16 +61584,16 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordNullableArray", + OperationName: "TestRequestStringMACArray", OperationSummary: "", - OperationID: "test_request_string_password_nullable_array", + OperationID: "test_request_string_mac_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilString + Request = []net.HardwareAddr Params = struct{} Response = *Error ) @@ -61597,12 +61606,12 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringPasswordNullableArray(ctx, request) + response, err = s.h.TestRequestStringMACArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringPasswordNullableArray(ctx, request) + response, err = s.h.TestRequestStringMACArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -61610,7 +61619,7 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringPasswordNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringMACArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61619,18 +61628,18 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]str } } -// handleTestRequestStringPasswordNullableArrayArrayRequest handles test_request_string_password_nullable_array_array operation. +// handleTestRequestStringMACArrayArrayRequest handles test_request_string_mac_array_array operation. // -// POST /test_request_string_password_nullable_array_array -func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_mac_array_array +func (s *Server) handleTestRequestStringMACArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_password_nullable_array_array"), + otelogen.OperationID("test_request_string_mac_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_password_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_mac_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(), "TestRequestStringMACArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61655,11 +61664,11 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringPasswordNullableArrayArray", - ID: "test_request_string_password_nullable_array_array", + Name: "TestRequestStringMACArrayArray", + ID: "test_request_string_mac_array_array", } ) - request, close, err := s.decodeTestRequestStringPasswordNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringMACArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61679,16 +61688,16 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringPasswordNullableArrayArray", + OperationName: "TestRequestStringMACArrayArray", OperationSummary: "", - OperationID: "test_request_string_password_nullable_array_array", + OperationID: "test_request_string_mac_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilString + Request = [][]net.HardwareAddr Params = struct{} Response = *Error ) @@ -61701,12 +61710,12 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringMACArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringMACArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -61714,7 +61723,7 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringMACArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61723,18 +61732,18 @@ func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [ } } -// handleTestRequestStringTimeRequest handles test_request_string_time operation. +// handleTestRequestStringMACNullableRequest handles test_request_string_mac_nullable operation. // -// POST /test_request_string_time -func (s *Server) handleTestRequestStringTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_mac_nullable +func (s *Server) handleTestRequestStringMACNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time"), + otelogen.OperationID("test_request_string_mac_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_time"), + semconv.HTTPRouteKey.String("/test_request_string_mac_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringMACNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61759,11 +61768,11 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTime", - ID: "test_request_string_time", + Name: "TestRequestStringMACNullable", + ID: "test_request_string_mac_nullable", } ) - request, close, err := s.decodeTestRequestStringTimeRequest(r) + request, close, err := s.decodeTestRequestStringMACNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61783,16 +61792,16 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTime", + OperationName: "TestRequestStringMACNullable", OperationSummary: "", - OperationID: "test_request_string_time", + OperationID: "test_request_string_mac_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptTime + Request = OptNilHardwareAddr Params = struct{} Response = *Error ) @@ -61805,12 +61814,12 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringTime(ctx, request) + response, err = s.h.TestRequestStringMACNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringTime(ctx, request) + response, err = s.h.TestRequestStringMACNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -61818,7 +61827,7 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringTimeResponse(response, w, span); err != nil { + if err := encodeTestRequestStringMACNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61827,18 +61836,18 @@ func (s *Server) handleTestRequestStringTimeRequest(args [0]string, argsEscaped } } -// handleTestRequestStringTimeArrayRequest handles test_request_string_time_array operation. +// handleTestRequestStringMACNullableArrayRequest handles test_request_string_mac_nullable_array operation. // -// POST /test_request_string_time_array -func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_mac_nullable_array +func (s *Server) handleTestRequestStringMACNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_array"), + otelogen.OperationID("test_request_string_mac_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_time_array"), + semconv.HTTPRouteKey.String("/test_request_string_mac_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringMACNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61863,11 +61872,11 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeArray", - ID: "test_request_string_time_array", + Name: "TestRequestStringMACNullableArray", + ID: "test_request_string_mac_nullable_array", } ) - request, close, err := s.decodeTestRequestStringTimeArrayRequest(r) + request, close, err := s.decodeTestRequestStringMACNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61887,16 +61896,16 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeArray", + OperationName: "TestRequestStringMACNullableArray", OperationSummary: "", - OperationID: "test_request_string_time_array", + OperationID: "test_request_string_mac_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = []NilHardwareAddr Params = struct{} Response = *Error ) @@ -61909,12 +61918,12 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringTimeArray(ctx, request) + response, err = s.h.TestRequestStringMACNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringTimeArray(ctx, request) + response, err = s.h.TestRequestStringMACNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -61922,7 +61931,7 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringMACNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -61931,18 +61940,18 @@ func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringTimeArrayArrayRequest handles test_request_string_time_array_array operation. +// handleTestRequestStringMACNullableArrayArrayRequest handles test_request_string_mac_nullable_array_array operation. // -// POST /test_request_string_time_array_array -func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_mac_nullable_array_array +func (s *Server) handleTestRequestStringMACNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_array_array"), + otelogen.OperationID("test_request_string_mac_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_time_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_mac_nullable_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(), "TestRequestStringMACNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -61967,11 +61976,11 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeArrayArray", - ID: "test_request_string_time_array_array", + Name: "TestRequestStringMACNullableArrayArray", + ID: "test_request_string_mac_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringTimeArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringMACNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -61991,16 +62000,16 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeArrayArray", + OperationName: "TestRequestStringMACNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_time_array_array", + OperationID: "test_request_string_mac_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilHardwareAddr Params = struct{} Response = *Error ) @@ -62013,12 +62022,12 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringTimeArrayArray(ctx, request) + response, err = s.h.TestRequestStringMACNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringTimeArrayArray(ctx, request) + response, err = s.h.TestRequestStringMACNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -62026,7 +62035,7 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringMACNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62035,18 +62044,18 @@ func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringTimeNullableRequest handles test_request_string_time_nullable operation. +// handleTestRequestStringNullableRequest handles test_request_string_nullable operation. // -// POST /test_request_string_time_nullable -func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_nullable +func (s *Server) handleTestRequestStringNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable"), + otelogen.OperationID("test_request_string_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_time_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62071,11 +62080,11 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeNullable", - ID: "test_request_string_time_nullable", + Name: "TestRequestStringNullable", + ID: "test_request_string_nullable", } ) - request, close, err := s.decodeTestRequestStringTimeNullableRequest(r) + request, close, err := s.decodeTestRequestStringNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62095,16 +62104,16 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeNullable", + OperationName: "TestRequestStringNullable", OperationSummary: "", - OperationID: "test_request_string_time_nullable", + OperationID: "test_request_string_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilTime + Request = OptNilString Params = struct{} Response = *Error ) @@ -62117,12 +62126,12 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringTimeNullable(ctx, request) + response, err = s.h.TestRequestStringNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringTimeNullable(ctx, request) + response, err = s.h.TestRequestStringNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -62130,7 +62139,7 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, args return } - if err := encodeTestRequestStringTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62139,18 +62148,18 @@ func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, args } } -// handleTestRequestStringTimeNullableArrayRequest handles test_request_string_time_nullable_array operation. +// handleTestRequestStringNullableArrayRequest handles test_request_string_nullable_array operation. // -// POST /test_request_string_time_nullable_array -func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_nullable_array +func (s *Server) handleTestRequestStringNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable_array"), + otelogen.OperationID("test_request_string_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_time_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_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(), "TestRequestStringNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62175,11 +62184,11 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeNullableArray", - ID: "test_request_string_time_nullable_array", + Name: "TestRequestStringNullableArray", + ID: "test_request_string_nullable_array", } ) - request, close, err := s.decodeTestRequestStringTimeNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62199,16 +62208,16 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeNullableArray", + OperationName: "TestRequestStringNullableArray", OperationSummary: "", - OperationID: "test_request_string_time_nullable_array", + OperationID: "test_request_string_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilTime + Request = []NilString Params = struct{} Response = *Error ) @@ -62221,12 +62230,12 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringTimeNullableArray(ctx, request) + response, err = s.h.TestRequestStringNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringTimeNullableArray(ctx, request) + response, err = s.h.TestRequestStringNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -62234,7 +62243,7 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62243,18 +62252,18 @@ func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, } } -// handleTestRequestStringTimeNullableArrayArrayRequest handles test_request_string_time_nullable_array_array operation. +// handleTestRequestStringNullableArrayArrayRequest handles test_request_string_nullable_array_array operation. // -// POST /test_request_string_time_nullable_array_array -func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_nullable_array_array +func (s *Server) handleTestRequestStringNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_time_nullable_array_array"), + otelogen.OperationID("test_request_string_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_time_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_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(), "TestRequestStringNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62279,11 +62288,11 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringTimeNullableArrayArray", - ID: "test_request_string_time_nullable_array_array", + Name: "TestRequestStringNullableArrayArray", + ID: "test_request_string_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringTimeNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62303,16 +62312,16 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringTimeNullableArrayArray", + OperationName: "TestRequestStringNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_time_nullable_array_array", + OperationID: "test_request_string_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilTime + Request = [][]NilString Params = struct{} Response = *Error ) @@ -62325,12 +62334,12 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringTimeNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -62338,7 +62347,7 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62347,18 +62356,18 @@ func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringURIRequest handles test_request_string_uri operation. +// handleTestRequestStringPasswordRequest handles test_request_string_password operation. // -// POST /test_request_string_uri -func (s *Server) handleTestRequestStringURIRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password +func (s *Server) handleTestRequestStringPasswordRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri"), + otelogen.OperationID("test_request_string_password"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uri"), + semconv.HTTPRouteKey.String("/test_request_string_password"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURI", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPassword", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62383,11 +62392,11 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, argsEscaped b } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURI", - ID: "test_request_string_uri", + Name: "TestRequestStringPassword", + ID: "test_request_string_password", } ) - request, close, err := s.decodeTestRequestStringURIRequest(r) + request, close, err := s.decodeTestRequestStringPasswordRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62407,16 +62416,16 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, argsEscaped b if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURI", + OperationName: "TestRequestStringPassword", OperationSummary: "", - OperationID: "test_request_string_uri", + OperationID: "test_request_string_password", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptURI + Request = OptString Params = struct{} Response = *Error ) @@ -62429,12 +62438,12 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, argsEscaped b mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringURI(ctx, request) + response, err = s.h.TestRequestStringPassword(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringURI(ctx, request) + response, err = s.h.TestRequestStringPassword(ctx, request) } if err != nil { recordError("Internal", err) @@ -62442,7 +62451,7 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, argsEscaped b return } - if err := encodeTestRequestStringURIResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62451,18 +62460,18 @@ func (s *Server) handleTestRequestStringURIRequest(args [0]string, argsEscaped b } } -// handleTestRequestStringURIArrayRequest handles test_request_string_uri_array operation. +// handleTestRequestStringPasswordArrayRequest handles test_request_string_password_array operation. // -// POST /test_request_string_uri_array -func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_array +func (s *Server) handleTestRequestStringPasswordArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_array"), + otelogen.OperationID("test_request_string_password_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uri_array"), + semconv.HTTPRouteKey.String("/test_request_string_password_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURIArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62487,11 +62496,11 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURIArray", - ID: "test_request_string_uri_array", + Name: "TestRequestStringPasswordArray", + ID: "test_request_string_password_array", } ) - request, close, err := s.decodeTestRequestStringURIArrayRequest(r) + request, close, err := s.decodeTestRequestStringPasswordArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62511,16 +62520,16 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURIArray", + OperationName: "TestRequestStringPasswordArray", OperationSummary: "", - OperationID: "test_request_string_uri_array", + OperationID: "test_request_string_password_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []url.URL + Request = []string Params = struct{} Response = *Error ) @@ -62533,12 +62542,12 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringURIArray(ctx, request) + response, err = s.h.TestRequestStringPasswordArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringURIArray(ctx, request) + response, err = s.h.TestRequestStringPasswordArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -62546,7 +62555,7 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringURIArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62555,18 +62564,18 @@ func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, argsEsca } } -// handleTestRequestStringURIArrayArrayRequest handles test_request_string_uri_array_array operation. +// handleTestRequestStringPasswordArrayArrayRequest handles test_request_string_password_array_array operation. // -// POST /test_request_string_uri_array_array -func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_array_array +func (s *Server) handleTestRequestStringPasswordArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_array_array"), + otelogen.OperationID("test_request_string_password_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uri_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_password_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(), "TestRequestStringPasswordArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62591,11 +62600,11 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURIArrayArray", - ID: "test_request_string_uri_array_array", + Name: "TestRequestStringPasswordArrayArray", + ID: "test_request_string_password_array_array", } ) - request, close, err := s.decodeTestRequestStringURIArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringPasswordArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62615,16 +62624,16 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURIArrayArray", + OperationName: "TestRequestStringPasswordArrayArray", OperationSummary: "", - OperationID: "test_request_string_uri_array_array", + OperationID: "test_request_string_password_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]url.URL + Request = [][]string Params = struct{} Response = *Error ) @@ -62637,12 +62646,12 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringURIArrayArray(ctx, request) + response, err = s.h.TestRequestStringPasswordArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringURIArrayArray(ctx, request) + response, err = s.h.TestRequestStringPasswordArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -62650,7 +62659,7 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringURIArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62659,18 +62668,18 @@ func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, arg } } -// handleTestRequestStringURINullableRequest handles test_request_string_uri_nullable operation. +// handleTestRequestStringPasswordNullableRequest handles test_request_string_password_nullable operation. // -// POST /test_request_string_uri_nullable -func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_nullable +func (s *Server) handleTestRequestStringPasswordNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable"), + otelogen.OperationID("test_request_string_password_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uri_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_password_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringPasswordNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62695,11 +62704,11 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURINullable", - ID: "test_request_string_uri_nullable", + Name: "TestRequestStringPasswordNullable", + ID: "test_request_string_password_nullable", } ) - request, close, err := s.decodeTestRequestStringURINullableRequest(r) + request, close, err := s.decodeTestRequestStringPasswordNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62719,16 +62728,16 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURINullable", + OperationName: "TestRequestStringPasswordNullable", OperationSummary: "", - OperationID: "test_request_string_uri_nullable", + OperationID: "test_request_string_password_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilURI + Request = OptNilString Params = struct{} Response = *Error ) @@ -62741,12 +62750,12 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringURINullable(ctx, request) + response, err = s.h.TestRequestStringPasswordNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringURINullable(ctx, request) + response, err = s.h.TestRequestStringPasswordNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -62754,7 +62763,7 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, argsE return } - if err := encodeTestRequestStringURINullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62763,18 +62772,18 @@ func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, argsE } } -// handleTestRequestStringURINullableArrayRequest handles test_request_string_uri_nullable_array operation. +// handleTestRequestStringPasswordNullableArrayRequest handles test_request_string_password_nullable_array operation. // -// POST /test_request_string_uri_nullable_array -func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_nullable_array +func (s *Server) handleTestRequestStringPasswordNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable_array"), + otelogen.OperationID("test_request_string_password_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uri_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_password_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(), "TestRequestStringPasswordNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62799,11 +62808,11 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURINullableArray", - ID: "test_request_string_uri_nullable_array", + Name: "TestRequestStringPasswordNullableArray", + ID: "test_request_string_password_nullable_array", } ) - request, close, err := s.decodeTestRequestStringURINullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringPasswordNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62823,16 +62832,16 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURINullableArray", + OperationName: "TestRequestStringPasswordNullableArray", OperationSummary: "", - OperationID: "test_request_string_uri_nullable_array", + OperationID: "test_request_string_password_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilURI + Request = []NilString Params = struct{} Response = *Error ) @@ -62845,12 +62854,12 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringURINullableArray(ctx, request) + response, err = s.h.TestRequestStringPasswordNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringURINullableArray(ctx, request) + response, err = s.h.TestRequestStringPasswordNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -62858,7 +62867,7 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringURINullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62867,18 +62876,18 @@ func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, } } -// handleTestRequestStringURINullableArrayArrayRequest handles test_request_string_uri_nullable_array_array operation. +// handleTestRequestStringPasswordNullableArrayArrayRequest handles test_request_string_password_nullable_array_array operation. // -// POST /test_request_string_uri_nullable_array_array -func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_password_nullable_array_array +func (s *Server) handleTestRequestStringPasswordNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uri_nullable_array_array"), + otelogen.OperationID("test_request_string_password_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uri_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_password_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(), "TestRequestStringPasswordNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -62903,11 +62912,11 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringURINullableArrayArray", - ID: "test_request_string_uri_nullable_array_array", + Name: "TestRequestStringPasswordNullableArrayArray", + ID: "test_request_string_password_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringURINullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringPasswordNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -62927,16 +62936,16 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringURINullableArrayArray", + OperationName: "TestRequestStringPasswordNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_uri_nullable_array_array", + OperationID: "test_request_string_password_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilURI + Request = [][]NilString Params = struct{} Response = *Error ) @@ -62949,12 +62958,12 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringURINullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringURINullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringPasswordNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -62962,7 +62971,7 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str return } - if err := encodeTestRequestStringURINullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringPasswordNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -62971,18 +62980,18 @@ func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]str } } -// handleTestRequestStringUUIDRequest handles test_request_string_uuid operation. +// handleTestRequestStringTimeRequest handles test_request_string_time operation. // -// POST /test_request_string_uuid -func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time +func (s *Server) handleTestRequestStringTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid"), + otelogen.OperationID("test_request_string_time"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uuid"), + semconv.HTTPRouteKey.String("/test_request_string_time"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUID", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTime", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63007,11 +63016,11 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUID", - ID: "test_request_string_uuid", + Name: "TestRequestStringTime", + ID: "test_request_string_time", } ) - request, close, err := s.decodeTestRequestStringUUIDRequest(r) + request, close, err := s.decodeTestRequestStringTimeRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63031,16 +63040,16 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUID", + OperationName: "TestRequestStringTime", OperationSummary: "", - OperationID: "test_request_string_uuid", + OperationID: "test_request_string_time", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptUUID + Request = OptTime Params = struct{} Response = *Error ) @@ -63053,12 +63062,12 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUUID(ctx, request) + response, err = s.h.TestRequestStringTime(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUUID(ctx, request) + response, err = s.h.TestRequestStringTime(ctx, request) } if err != nil { recordError("Internal", err) @@ -63066,7 +63075,7 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringUUIDResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63075,18 +63084,18 @@ func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, argsEscaped } } -// handleTestRequestStringUUIDArrayRequest handles test_request_string_uuid_array operation. +// handleTestRequestStringTimeArrayRequest handles test_request_string_time_array operation. // -// POST /test_request_string_uuid_array -func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_array +func (s *Server) handleTestRequestStringTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_array"), + otelogen.OperationID("test_request_string_time_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uuid_array"), + semconv.HTTPRouteKey.String("/test_request_string_time_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63111,11 +63120,11 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDArray", - ID: "test_request_string_uuid_array", + Name: "TestRequestStringTimeArray", + ID: "test_request_string_time_array", } ) - request, close, err := s.decodeTestRequestStringUUIDArrayRequest(r) + request, close, err := s.decodeTestRequestStringTimeArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63135,16 +63144,16 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDArray", + OperationName: "TestRequestStringTimeArray", OperationSummary: "", - OperationID: "test_request_string_uuid_array", + OperationID: "test_request_string_time_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uuid.UUID + Request = []time.Time Params = struct{} Response = *Error ) @@ -63157,12 +63166,12 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUUIDArray(ctx, request) + response, err = s.h.TestRequestStringTimeArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUUIDArray(ctx, request) + response, err = s.h.TestRequestStringTimeArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -63170,7 +63179,7 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringUUIDArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63179,18 +63188,18 @@ func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringUUIDArrayArrayRequest handles test_request_string_uuid_array_array operation. +// handleTestRequestStringTimeArrayArrayRequest handles test_request_string_time_array_array operation. // -// POST /test_request_string_uuid_array_array -func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_array_array +func (s *Server) handleTestRequestStringTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_array_array"), + otelogen.OperationID("test_request_string_time_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uuid_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_time_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(), "TestRequestStringTimeArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63215,11 +63224,11 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDArrayArray", - ID: "test_request_string_uuid_array_array", + Name: "TestRequestStringTimeArrayArray", + ID: "test_request_string_time_array_array", } ) - request, close, err := s.decodeTestRequestStringUUIDArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringTimeArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63239,16 +63248,16 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDArrayArray", + OperationName: "TestRequestStringTimeArrayArray", OperationSummary: "", - OperationID: "test_request_string_uuid_array_array", + OperationID: "test_request_string_time_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uuid.UUID + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -63261,12 +63270,12 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUUIDArrayArray(ctx, request) + response, err = s.h.TestRequestStringTimeArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUUIDArrayArray(ctx, request) + response, err = s.h.TestRequestStringTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -63274,7 +63283,7 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringUUIDArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63283,18 +63292,18 @@ func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringUUIDNullableRequest handles test_request_string_uuid_nullable operation. +// handleTestRequestStringTimeNullableRequest handles test_request_string_time_nullable operation. // -// POST /test_request_string_uuid_nullable -func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_nullable +func (s *Server) handleTestRequestStringTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable"), + otelogen.OperationID("test_request_string_time_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uuid_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringTimeNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63319,11 +63328,11 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDNullable", - ID: "test_request_string_uuid_nullable", + Name: "TestRequestStringTimeNullable", + ID: "test_request_string_time_nullable", } ) - request, close, err := s.decodeTestRequestStringUUIDNullableRequest(r) + request, close, err := s.decodeTestRequestStringTimeNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63343,16 +63352,16 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDNullable", + OperationName: "TestRequestStringTimeNullable", OperationSummary: "", - OperationID: "test_request_string_uuid_nullable", + OperationID: "test_request_string_time_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilUUID + Request = OptNilTime Params = struct{} Response = *Error ) @@ -63365,12 +63374,12 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUUIDNullable(ctx, request) + response, err = s.h.TestRequestStringTimeNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUUIDNullable(ctx, request) + response, err = s.h.TestRequestStringTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -63378,7 +63387,7 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, args return } - if err := encodeTestRequestStringUUIDNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63387,18 +63396,18 @@ func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, args } } -// handleTestRequestStringUUIDNullableArrayRequest handles test_request_string_uuid_nullable_array operation. +// handleTestRequestStringTimeNullableArrayRequest handles test_request_string_time_nullable_array operation. // -// POST /test_request_string_uuid_nullable_array -func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_nullable_array +func (s *Server) handleTestRequestStringTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable_array"), + otelogen.OperationID("test_request_string_time_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uuid_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_time_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(), "TestRequestStringTimeNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63423,11 +63432,11 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDNullableArray", - ID: "test_request_string_uuid_nullable_array", + Name: "TestRequestStringTimeNullableArray", + ID: "test_request_string_time_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUUIDNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringTimeNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63447,16 +63456,16 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDNullableArray", + OperationName: "TestRequestStringTimeNullableArray", OperationSummary: "", - OperationID: "test_request_string_uuid_nullable_array", + OperationID: "test_request_string_time_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilUUID + Request = []NilTime Params = struct{} Response = *Error ) @@ -63469,12 +63478,12 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUUIDNullableArray(ctx, request) + response, err = s.h.TestRequestStringTimeNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUUIDNullableArray(ctx, request) + response, err = s.h.TestRequestStringTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -63482,7 +63491,7 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUUIDNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63491,18 +63500,18 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, } } -// handleTestRequestStringUUIDNullableArrayArrayRequest handles test_request_string_uuid_nullable_array_array operation. +// handleTestRequestStringTimeNullableArrayArrayRequest handles test_request_string_time_nullable_array_array operation. // -// POST /test_request_string_uuid_nullable_array_array -func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_time_nullable_array_array +func (s *Server) handleTestRequestStringTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uuid_nullable_array_array"), + otelogen.OperationID("test_request_string_time_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uuid_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_time_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(), "TestRequestStringTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63527,11 +63536,11 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUUIDNullableArrayArray", - ID: "test_request_string_uuid_nullable_array_array", + Name: "TestRequestStringTimeNullableArrayArray", + ID: "test_request_string_time_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUUIDNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringTimeNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63551,16 +63560,16 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUUIDNullableArrayArray", + OperationName: "TestRequestStringTimeNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_uuid_nullable_array_array", + OperationID: "test_request_string_time_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilUUID + Request = [][]NilTime Params = struct{} Response = *Error ) @@ -63573,12 +63582,12 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringTimeNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -63586,7 +63595,7 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63595,18 +63604,18 @@ func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringUintRequest handles test_request_string_uint operation. +// handleTestRequestStringURIRequest handles test_request_string_uri operation. // -// POST /test_request_string_uint -func (s *Server) handleTestRequestStringUintRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uri +func (s *Server) handleTestRequestStringURIRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint"), + otelogen.OperationID("test_request_string_uri"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint"), + semconv.HTTPRouteKey.String("/test_request_string_uri"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURI", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63631,11 +63640,11 @@ func (s *Server) handleTestRequestStringUintRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint", - ID: "test_request_string_uint", + Name: "TestRequestStringURI", + ID: "test_request_string_uri", } ) - request, close, err := s.decodeTestRequestStringUintRequest(r) + request, close, err := s.decodeTestRequestStringURIRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63655,16 +63664,16 @@ func (s *Server) handleTestRequestStringUintRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint", + OperationName: "TestRequestStringURI", OperationSummary: "", - OperationID: "test_request_string_uint", + OperationID: "test_request_string_uri", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUint + Request = OptURI Params = struct{} Response = *Error ) @@ -63677,12 +63686,12 @@ func (s *Server) handleTestRequestStringUintRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint(ctx, request) + response, err = s.h.TestRequestStringURI(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint(ctx, request) + response, err = s.h.TestRequestStringURI(ctx, request) } if err != nil { recordError("Internal", err) @@ -63690,7 +63699,7 @@ func (s *Server) handleTestRequestStringUintRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringUintResponse(response, w, span); err != nil { + if err := encodeTestRequestStringURIResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63699,18 +63708,18 @@ func (s *Server) handleTestRequestStringUintRequest(args [0]string, argsEscaped } } -// handleTestRequestStringUint16Request handles test_request_string_uint16 operation. +// handleTestRequestStringURIArrayRequest handles test_request_string_uri_array operation. // -// POST /test_request_string_uint16 -func (s *Server) handleTestRequestStringUint16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uri_array +func (s *Server) handleTestRequestStringURIArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint16"), + otelogen.OperationID("test_request_string_uri_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint16"), + semconv.HTTPRouteKey.String("/test_request_string_uri_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURIArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63735,11 +63744,11 @@ func (s *Server) handleTestRequestStringUint16Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint16", - ID: "test_request_string_uint16", + Name: "TestRequestStringURIArray", + ID: "test_request_string_uri_array", } ) - request, close, err := s.decodeTestRequestStringUint16Request(r) + request, close, err := s.decodeTestRequestStringURIArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63759,16 +63768,16 @@ func (s *Server) handleTestRequestStringUint16Request(args [0]string, argsEscape if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint16", + OperationName: "TestRequestStringURIArray", OperationSummary: "", - OperationID: "test_request_string_uint16", + OperationID: "test_request_string_uri_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUint16 + Request = []url.URL Params = struct{} Response = *Error ) @@ -63781,12 +63790,12 @@ func (s *Server) handleTestRequestStringUint16Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint16(ctx, request) + response, err = s.h.TestRequestStringURIArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint16(ctx, request) + response, err = s.h.TestRequestStringURIArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -63794,7 +63803,7 @@ func (s *Server) handleTestRequestStringUint16Request(args [0]string, argsEscape return } - if err := encodeTestRequestStringUint16Response(response, w, span); err != nil { + if err := encodeTestRequestStringURIArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63803,18 +63812,18 @@ func (s *Server) handleTestRequestStringUint16Request(args [0]string, argsEscape } } -// handleTestRequestStringUint16ArrayRequest handles test_request_string_uint16_array operation. +// handleTestRequestStringURIArrayArrayRequest handles test_request_string_uri_array_array operation. // -// POST /test_request_string_uint16_array -func (s *Server) handleTestRequestStringUint16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uri_array_array +func (s *Server) handleTestRequestStringURIArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint16_array"), + otelogen.OperationID("test_request_string_uri_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint16_array"), + semconv.HTTPRouteKey.String("/test_request_string_uri_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURIArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63839,11 +63848,11 @@ func (s *Server) handleTestRequestStringUint16ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint16Array", - ID: "test_request_string_uint16_array", + Name: "TestRequestStringURIArrayArray", + ID: "test_request_string_uri_array_array", } ) - request, close, err := s.decodeTestRequestStringUint16ArrayRequest(r) + request, close, err := s.decodeTestRequestStringURIArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63863,16 +63872,16 @@ func (s *Server) handleTestRequestStringUint16ArrayRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint16Array", + OperationName: "TestRequestStringURIArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint16_array", + OperationID: "test_request_string_uri_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint16 + Request = [][]url.URL Params = struct{} Response = *Error ) @@ -63885,12 +63894,12 @@ func (s *Server) handleTestRequestStringUint16ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint16Array(ctx, request) + response, err = s.h.TestRequestStringURIArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint16Array(ctx, request) + response, err = s.h.TestRequestStringURIArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -63898,7 +63907,7 @@ func (s *Server) handleTestRequestStringUint16ArrayRequest(args [0]string, argsE return } - if err := encodeTestRequestStringUint16ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringURIArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -63907,18 +63916,18 @@ func (s *Server) handleTestRequestStringUint16ArrayRequest(args [0]string, argsE } } -// handleTestRequestStringUint16ArrayArrayRequest handles test_request_string_uint16_array_array operation. +// handleTestRequestStringURINullableRequest handles test_request_string_uri_nullable operation. // -// POST /test_request_string_uint16_array_array -func (s *Server) handleTestRequestStringUint16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uri_nullable +func (s *Server) handleTestRequestStringURINullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint16_array_array"), + otelogen.OperationID("test_request_string_uri_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint16_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uri_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -63943,11 +63952,11 @@ func (s *Server) handleTestRequestStringUint16ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint16ArrayArray", - ID: "test_request_string_uint16_array_array", + Name: "TestRequestStringURINullable", + ID: "test_request_string_uri_nullable", } ) - request, close, err := s.decodeTestRequestStringUint16ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringURINullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -63967,16 +63976,16 @@ func (s *Server) handleTestRequestStringUint16ArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint16ArrayArray", + OperationName: "TestRequestStringURINullable", OperationSummary: "", - OperationID: "test_request_string_uint16_array_array", + OperationID: "test_request_string_uri_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint16 + Request = OptNilURI Params = struct{} Response = *Error ) @@ -63989,12 +63998,12 @@ func (s *Server) handleTestRequestStringUint16ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint16ArrayArray(ctx, request) + response, err = s.h.TestRequestStringURINullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint16ArrayArray(ctx, request) + response, err = s.h.TestRequestStringURINullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -64002,7 +64011,7 @@ func (s *Server) handleTestRequestStringUint16ArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUint16ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringURINullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64011,18 +64020,18 @@ func (s *Server) handleTestRequestStringUint16ArrayArrayRequest(args [0]string, } } -// handleTestRequestStringUint16NullableRequest handles test_request_string_uint16_nullable operation. +// handleTestRequestStringURINullableArrayRequest handles test_request_string_uri_nullable_array operation. // -// POST /test_request_string_uint16_nullable -func (s *Server) handleTestRequestStringUint16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uri_nullable_array +func (s *Server) handleTestRequestStringURINullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint16_nullable"), + otelogen.OperationID("test_request_string_uri_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint16_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_uri_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64047,11 +64056,11 @@ func (s *Server) handleTestRequestStringUint16NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint16Nullable", - ID: "test_request_string_uint16_nullable", + Name: "TestRequestStringURINullableArray", + ID: "test_request_string_uri_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUint16NullableRequest(r) + request, close, err := s.decodeTestRequestStringURINullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64071,16 +64080,16 @@ func (s *Server) handleTestRequestStringUint16NullableRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint16Nullable", + OperationName: "TestRequestStringURINullableArray", OperationSummary: "", - OperationID: "test_request_string_uint16_nullable", + OperationID: "test_request_string_uri_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUint16 + Request = []NilURI Params = struct{} Response = *Error ) @@ -64093,12 +64102,12 @@ func (s *Server) handleTestRequestStringUint16NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint16Nullable(ctx, request) + response, err = s.h.TestRequestStringURINullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint16Nullable(ctx, request) + response, err = s.h.TestRequestStringURINullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -64106,7 +64115,7 @@ func (s *Server) handleTestRequestStringUint16NullableRequest(args [0]string, ar return } - if err := encodeTestRequestStringUint16NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringURINullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64115,18 +64124,18 @@ func (s *Server) handleTestRequestStringUint16NullableRequest(args [0]string, ar } } -// handleTestRequestStringUint16NullableArrayRequest handles test_request_string_uint16_nullable_array operation. +// handleTestRequestStringURINullableArrayArrayRequest handles test_request_string_uri_nullable_array_array operation. // -// POST /test_request_string_uint16_nullable_array -func (s *Server) handleTestRequestStringUint16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uri_nullable_array_array +func (s *Server) handleTestRequestStringURINullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint16_nullable_array"), + otelogen.OperationID("test_request_string_uri_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint16_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_uri_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringURINullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64151,11 +64160,11 @@ func (s *Server) handleTestRequestStringUint16NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint16NullableArray", - ID: "test_request_string_uint16_nullable_array", + Name: "TestRequestStringURINullableArrayArray", + ID: "test_request_string_uri_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUint16NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringURINullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64175,16 +64184,16 @@ func (s *Server) handleTestRequestStringUint16NullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint16NullableArray", + OperationName: "TestRequestStringURINullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint16_nullable_array", + OperationID: "test_request_string_uri_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint16 + Request = [][]NilURI Params = struct{} Response = *Error ) @@ -64197,12 +64206,12 @@ func (s *Server) handleTestRequestStringUint16NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint16NullableArray(ctx, request) + response, err = s.h.TestRequestStringURINullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint16NullableArray(ctx, request) + response, err = s.h.TestRequestStringURINullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -64210,7 +64219,7 @@ func (s *Server) handleTestRequestStringUint16NullableArrayRequest(args [0]strin return } - if err := encodeTestRequestStringUint16NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringURINullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64219,18 +64228,18 @@ func (s *Server) handleTestRequestStringUint16NullableArrayRequest(args [0]strin } } -// handleTestRequestStringUint16NullableArrayArrayRequest handles test_request_string_uint16_nullable_array_array operation. +// handleTestRequestStringUUIDRequest handles test_request_string_uuid operation. // -// POST /test_request_string_uint16_nullable_array_array -func (s *Server) handleTestRequestStringUint16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uuid +func (s *Server) handleTestRequestStringUUIDRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint16_nullable_array_array"), + otelogen.OperationID("test_request_string_uuid"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint16_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uuid"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUID", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64255,11 +64264,11 @@ func (s *Server) handleTestRequestStringUint16NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint16NullableArrayArray", - ID: "test_request_string_uint16_nullable_array_array", + Name: "TestRequestStringUUID", + ID: "test_request_string_uuid", } ) - request, close, err := s.decodeTestRequestStringUint16NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUUIDRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64279,16 +64288,16 @@ func (s *Server) handleTestRequestStringUint16NullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint16NullableArrayArray", + OperationName: "TestRequestStringUUID", OperationSummary: "", - OperationID: "test_request_string_uint16_nullable_array_array", + OperationID: "test_request_string_uuid", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint16 + Request = OptUUID Params = struct{} Response = *Error ) @@ -64301,12 +64310,12 @@ func (s *Server) handleTestRequestStringUint16NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint16NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUUID(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint16NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUUID(ctx, request) } if err != nil { recordError("Internal", err) @@ -64314,7 +64323,7 @@ func (s *Server) handleTestRequestStringUint16NullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestStringUint16NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUUIDResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64323,18 +64332,18 @@ func (s *Server) handleTestRequestStringUint16NullableArrayArrayRequest(args [0] } } -// handleTestRequestStringUint32Request handles test_request_string_uint32 operation. +// handleTestRequestStringUUIDArrayRequest handles test_request_string_uuid_array operation. // -// POST /test_request_string_uint32 -func (s *Server) handleTestRequestStringUint32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uuid_array +func (s *Server) handleTestRequestStringUUIDArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint32"), + otelogen.OperationID("test_request_string_uuid_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint32"), + semconv.HTTPRouteKey.String("/test_request_string_uuid_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64359,11 +64368,11 @@ func (s *Server) handleTestRequestStringUint32Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint32", - ID: "test_request_string_uint32", + Name: "TestRequestStringUUIDArray", + ID: "test_request_string_uuid_array", } ) - request, close, err := s.decodeTestRequestStringUint32Request(r) + request, close, err := s.decodeTestRequestStringUUIDArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64383,16 +64392,16 @@ func (s *Server) handleTestRequestStringUint32Request(args [0]string, argsEscape if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint32", + OperationName: "TestRequestStringUUIDArray", OperationSummary: "", - OperationID: "test_request_string_uint32", + OperationID: "test_request_string_uuid_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUint32 + Request = []uuid.UUID Params = struct{} Response = *Error ) @@ -64405,12 +64414,12 @@ func (s *Server) handleTestRequestStringUint32Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint32(ctx, request) + response, err = s.h.TestRequestStringUUIDArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint32(ctx, request) + response, err = s.h.TestRequestStringUUIDArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -64418,7 +64427,7 @@ func (s *Server) handleTestRequestStringUint32Request(args [0]string, argsEscape return } - if err := encodeTestRequestStringUint32Response(response, w, span); err != nil { + if err := encodeTestRequestStringUUIDArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64427,18 +64436,18 @@ func (s *Server) handleTestRequestStringUint32Request(args [0]string, argsEscape } } -// handleTestRequestStringUint32ArrayRequest handles test_request_string_uint32_array operation. +// handleTestRequestStringUUIDArrayArrayRequest handles test_request_string_uuid_array_array operation. // -// POST /test_request_string_uint32_array -func (s *Server) handleTestRequestStringUint32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uuid_array_array +func (s *Server) handleTestRequestStringUUIDArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint32_array"), + otelogen.OperationID("test_request_string_uuid_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint32_array"), + semconv.HTTPRouteKey.String("/test_request_string_uuid_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64463,11 +64472,11 @@ func (s *Server) handleTestRequestStringUint32ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint32Array", - ID: "test_request_string_uint32_array", + Name: "TestRequestStringUUIDArrayArray", + ID: "test_request_string_uuid_array_array", } ) - request, close, err := s.decodeTestRequestStringUint32ArrayRequest(r) + request, close, err := s.decodeTestRequestStringUUIDArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64487,16 +64496,16 @@ func (s *Server) handleTestRequestStringUint32ArrayRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint32Array", + OperationName: "TestRequestStringUUIDArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint32_array", + OperationID: "test_request_string_uuid_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint32 + Request = [][]uuid.UUID Params = struct{} Response = *Error ) @@ -64509,12 +64518,12 @@ func (s *Server) handleTestRequestStringUint32ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint32Array(ctx, request) + response, err = s.h.TestRequestStringUUIDArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint32Array(ctx, request) + response, err = s.h.TestRequestStringUUIDArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -64522,7 +64531,7 @@ func (s *Server) handleTestRequestStringUint32ArrayRequest(args [0]string, argsE return } - if err := encodeTestRequestStringUint32ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUUIDArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64531,18 +64540,18 @@ func (s *Server) handleTestRequestStringUint32ArrayRequest(args [0]string, argsE } } -// handleTestRequestStringUint32ArrayArrayRequest handles test_request_string_uint32_array_array operation. +// handleTestRequestStringUUIDNullableRequest handles test_request_string_uuid_nullable operation. // -// POST /test_request_string_uint32_array_array -func (s *Server) handleTestRequestStringUint32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uuid_nullable +func (s *Server) handleTestRequestStringUUIDNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint32_array_array"), + otelogen.OperationID("test_request_string_uuid_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint32_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uuid_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64567,11 +64576,11 @@ func (s *Server) handleTestRequestStringUint32ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint32ArrayArray", - ID: "test_request_string_uint32_array_array", + Name: "TestRequestStringUUIDNullable", + ID: "test_request_string_uuid_nullable", } ) - request, close, err := s.decodeTestRequestStringUint32ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUUIDNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64591,16 +64600,16 @@ func (s *Server) handleTestRequestStringUint32ArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint32ArrayArray", + OperationName: "TestRequestStringUUIDNullable", OperationSummary: "", - OperationID: "test_request_string_uint32_array_array", + OperationID: "test_request_string_uuid_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint32 + Request = OptNilUUID Params = struct{} Response = *Error ) @@ -64613,12 +64622,12 @@ func (s *Server) handleTestRequestStringUint32ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint32ArrayArray(ctx, request) + response, err = s.h.TestRequestStringUUIDNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint32ArrayArray(ctx, request) + response, err = s.h.TestRequestStringUUIDNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -64626,7 +64635,7 @@ func (s *Server) handleTestRequestStringUint32ArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUint32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUUIDNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64635,18 +64644,18 @@ func (s *Server) handleTestRequestStringUint32ArrayArrayRequest(args [0]string, } } -// handleTestRequestStringUint32NullableRequest handles test_request_string_uint32_nullable operation. +// handleTestRequestStringUUIDNullableArrayRequest handles test_request_string_uuid_nullable_array operation. // -// POST /test_request_string_uint32_nullable -func (s *Server) handleTestRequestStringUint32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uuid_nullable_array +func (s *Server) handleTestRequestStringUUIDNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint32_nullable"), + otelogen.OperationID("test_request_string_uuid_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint32_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_uuid_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64671,11 +64680,11 @@ func (s *Server) handleTestRequestStringUint32NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint32Nullable", - ID: "test_request_string_uint32_nullable", + Name: "TestRequestStringUUIDNullableArray", + ID: "test_request_string_uuid_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUint32NullableRequest(r) + request, close, err := s.decodeTestRequestStringUUIDNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64695,16 +64704,16 @@ func (s *Server) handleTestRequestStringUint32NullableRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint32Nullable", + OperationName: "TestRequestStringUUIDNullableArray", OperationSummary: "", - OperationID: "test_request_string_uint32_nullable", + OperationID: "test_request_string_uuid_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUint32 + Request = []NilUUID Params = struct{} Response = *Error ) @@ -64717,12 +64726,12 @@ func (s *Server) handleTestRequestStringUint32NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint32Nullable(ctx, request) + response, err = s.h.TestRequestStringUUIDNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint32Nullable(ctx, request) + response, err = s.h.TestRequestStringUUIDNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -64730,7 +64739,7 @@ func (s *Server) handleTestRequestStringUint32NullableRequest(args [0]string, ar return } - if err := encodeTestRequestStringUint32NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUUIDNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64739,18 +64748,18 @@ func (s *Server) handleTestRequestStringUint32NullableRequest(args [0]string, ar } } -// handleTestRequestStringUint32NullableArrayRequest handles test_request_string_uint32_nullable_array operation. +// handleTestRequestStringUUIDNullableArrayArrayRequest handles test_request_string_uuid_nullable_array_array operation. // -// POST /test_request_string_uint32_nullable_array -func (s *Server) handleTestRequestStringUint32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uuid_nullable_array_array +func (s *Server) handleTestRequestStringUUIDNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint32_nullable_array"), + otelogen.OperationID("test_request_string_uuid_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint32_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_uuid_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUUIDNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64775,11 +64784,11 @@ func (s *Server) handleTestRequestStringUint32NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint32NullableArray", - ID: "test_request_string_uint32_nullable_array", + Name: "TestRequestStringUUIDNullableArrayArray", + ID: "test_request_string_uuid_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUint32NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUUIDNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64799,16 +64808,16 @@ func (s *Server) handleTestRequestStringUint32NullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint32NullableArray", + OperationName: "TestRequestStringUUIDNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint32_nullable_array", + OperationID: "test_request_string_uuid_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint32 + Request = [][]NilUUID Params = struct{} Response = *Error ) @@ -64821,12 +64830,12 @@ func (s *Server) handleTestRequestStringUint32NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint32NullableArray(ctx, request) + response, err = s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint32NullableArray(ctx, request) + response, err = s.h.TestRequestStringUUIDNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -64834,7 +64843,7 @@ func (s *Server) handleTestRequestStringUint32NullableArrayRequest(args [0]strin return } - if err := encodeTestRequestStringUint32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUUIDNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64843,18 +64852,18 @@ func (s *Server) handleTestRequestStringUint32NullableArrayRequest(args [0]strin } } -// handleTestRequestStringUint32NullableArrayArrayRequest handles test_request_string_uint32_nullable_array_array operation. +// handleTestRequestStringUintRequest handles test_request_string_uint operation. // -// POST /test_request_string_uint32_nullable_array_array -func (s *Server) handleTestRequestStringUint32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint +func (s *Server) handleTestRequestStringUintRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint32_nullable_array_array"), + otelogen.OperationID("test_request_string_uint"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64879,11 +64888,11 @@ func (s *Server) handleTestRequestStringUint32NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint32NullableArrayArray", - ID: "test_request_string_uint32_nullable_array_array", + Name: "TestRequestStringUint", + ID: "test_request_string_uint", } ) - request, close, err := s.decodeTestRequestStringUint32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUintRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -64903,16 +64912,16 @@ func (s *Server) handleTestRequestStringUint32NullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint32NullableArrayArray", + OperationName: "TestRequestStringUint", OperationSummary: "", - OperationID: "test_request_string_uint32_nullable_array_array", + OperationID: "test_request_string_uint", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint32 + Request = OptStringUint Params = struct{} Response = *Error ) @@ -64925,12 +64934,12 @@ func (s *Server) handleTestRequestStringUint32NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint32NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint(ctx, request) } if err != nil { recordError("Internal", err) @@ -64938,7 +64947,7 @@ func (s *Server) handleTestRequestStringUint32NullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestStringUint32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUintResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -64947,18 +64956,18 @@ func (s *Server) handleTestRequestStringUint32NullableArrayArrayRequest(args [0] } } -// handleTestRequestStringUint64Request handles test_request_string_uint64 operation. +// handleTestRequestStringUint16Request handles test_request_string_uint16 operation. // -// POST /test_request_string_uint64 -func (s *Server) handleTestRequestStringUint64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint16 +func (s *Server) handleTestRequestStringUint16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint64"), + otelogen.OperationID("test_request_string_uint16"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint64"), + semconv.HTTPRouteKey.String("/test_request_string_uint16"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -64983,11 +64992,11 @@ func (s *Server) handleTestRequestStringUint64Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint64", - ID: "test_request_string_uint64", + Name: "TestRequestStringUint16", + ID: "test_request_string_uint16", } ) - request, close, err := s.decodeTestRequestStringUint64Request(r) + request, close, err := s.decodeTestRequestStringUint16Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65007,16 +65016,16 @@ func (s *Server) handleTestRequestStringUint64Request(args [0]string, argsEscape if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint64", + OperationName: "TestRequestStringUint16", OperationSummary: "", - OperationID: "test_request_string_uint64", + OperationID: "test_request_string_uint16", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUint64 + Request = OptStringUint16 Params = struct{} Response = *Error ) @@ -65029,12 +65038,12 @@ func (s *Server) handleTestRequestStringUint64Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint64(ctx, request) + response, err = s.h.TestRequestStringUint16(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint64(ctx, request) + response, err = s.h.TestRequestStringUint16(ctx, request) } if err != nil { recordError("Internal", err) @@ -65042,7 +65051,7 @@ func (s *Server) handleTestRequestStringUint64Request(args [0]string, argsEscape return } - if err := encodeTestRequestStringUint64Response(response, w, span); err != nil { + if err := encodeTestRequestStringUint16Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65051,18 +65060,18 @@ func (s *Server) handleTestRequestStringUint64Request(args [0]string, argsEscape } } -// handleTestRequestStringUint64ArrayRequest handles test_request_string_uint64_array operation. +// handleTestRequestStringUint16ArrayRequest handles test_request_string_uint16_array operation. // -// POST /test_request_string_uint64_array -func (s *Server) handleTestRequestStringUint64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint16_array +func (s *Server) handleTestRequestStringUint16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint64_array"), + otelogen.OperationID("test_request_string_uint16_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint64_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint16_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65087,11 +65096,11 @@ func (s *Server) handleTestRequestStringUint64ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint64Array", - ID: "test_request_string_uint64_array", + Name: "TestRequestStringUint16Array", + ID: "test_request_string_uint16_array", } ) - request, close, err := s.decodeTestRequestStringUint64ArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint16ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65111,16 +65120,16 @@ func (s *Server) handleTestRequestStringUint64ArrayRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint64Array", + OperationName: "TestRequestStringUint16Array", OperationSummary: "", - OperationID: "test_request_string_uint64_array", + OperationID: "test_request_string_uint16_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint64 + Request = []uint16 Params = struct{} Response = *Error ) @@ -65133,12 +65142,12 @@ func (s *Server) handleTestRequestStringUint64ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint64Array(ctx, request) + response, err = s.h.TestRequestStringUint16Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint64Array(ctx, request) + response, err = s.h.TestRequestStringUint16Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -65146,7 +65155,7 @@ func (s *Server) handleTestRequestStringUint64ArrayRequest(args [0]string, argsE return } - if err := encodeTestRequestStringUint64ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint16ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65155,18 +65164,18 @@ func (s *Server) handleTestRequestStringUint64ArrayRequest(args [0]string, argsE } } -// handleTestRequestStringUint64ArrayArrayRequest handles test_request_string_uint64_array_array operation. +// handleTestRequestStringUint16ArrayArrayRequest handles test_request_string_uint16_array_array operation. // -// POST /test_request_string_uint64_array_array -func (s *Server) handleTestRequestStringUint64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint16_array_array +func (s *Server) handleTestRequestStringUint16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint64_array_array"), + otelogen.OperationID("test_request_string_uint16_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint64_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint16_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65191,11 +65200,11 @@ func (s *Server) handleTestRequestStringUint64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint64ArrayArray", - ID: "test_request_string_uint64_array_array", + Name: "TestRequestStringUint16ArrayArray", + ID: "test_request_string_uint16_array_array", } ) - request, close, err := s.decodeTestRequestStringUint64ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint16ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65215,16 +65224,16 @@ func (s *Server) handleTestRequestStringUint64ArrayArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint64ArrayArray", + OperationName: "TestRequestStringUint16ArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint64_array_array", + OperationID: "test_request_string_uint16_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint64 + Request = [][]uint16 Params = struct{} Response = *Error ) @@ -65237,12 +65246,12 @@ func (s *Server) handleTestRequestStringUint64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint64ArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint16ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint64ArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint16ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -65250,7 +65259,7 @@ func (s *Server) handleTestRequestStringUint64ArrayArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUint64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint16ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65259,18 +65268,18 @@ func (s *Server) handleTestRequestStringUint64ArrayArrayRequest(args [0]string, } } -// handleTestRequestStringUint64NullableRequest handles test_request_string_uint64_nullable operation. +// handleTestRequestStringUint16NullableRequest handles test_request_string_uint16_nullable operation. // -// POST /test_request_string_uint64_nullable -func (s *Server) handleTestRequestStringUint64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint16_nullable +func (s *Server) handleTestRequestStringUint16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint64_nullable"), + otelogen.OperationID("test_request_string_uint16_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint64_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_uint16_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65295,11 +65304,11 @@ func (s *Server) handleTestRequestStringUint64NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint64Nullable", - ID: "test_request_string_uint64_nullable", + Name: "TestRequestStringUint16Nullable", + ID: "test_request_string_uint16_nullable", } ) - request, close, err := s.decodeTestRequestStringUint64NullableRequest(r) + request, close, err := s.decodeTestRequestStringUint16NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65319,16 +65328,16 @@ func (s *Server) handleTestRequestStringUint64NullableRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint64Nullable", + OperationName: "TestRequestStringUint16Nullable", OperationSummary: "", - OperationID: "test_request_string_uint64_nullable", + OperationID: "test_request_string_uint16_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUint64 + Request = OptNilStringUint16 Params = struct{} Response = *Error ) @@ -65341,12 +65350,12 @@ func (s *Server) handleTestRequestStringUint64NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint64Nullable(ctx, request) + response, err = s.h.TestRequestStringUint16Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint64Nullable(ctx, request) + response, err = s.h.TestRequestStringUint16Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -65354,7 +65363,7 @@ func (s *Server) handleTestRequestStringUint64NullableRequest(args [0]string, ar return } - if err := encodeTestRequestStringUint64NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint16NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65363,18 +65372,18 @@ func (s *Server) handleTestRequestStringUint64NullableRequest(args [0]string, ar } } -// handleTestRequestStringUint64NullableArrayRequest handles test_request_string_uint64_nullable_array operation. +// handleTestRequestStringUint16NullableArrayRequest handles test_request_string_uint16_nullable_array operation. // -// POST /test_request_string_uint64_nullable_array -func (s *Server) handleTestRequestStringUint64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint16_nullable_array +func (s *Server) handleTestRequestStringUint16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint64_nullable_array"), + otelogen.OperationID("test_request_string_uint16_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint64_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint16_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65399,11 +65408,11 @@ func (s *Server) handleTestRequestStringUint64NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint64NullableArray", - ID: "test_request_string_uint64_nullable_array", + Name: "TestRequestStringUint16NullableArray", + ID: "test_request_string_uint16_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUint64NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint16NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65423,16 +65432,16 @@ func (s *Server) handleTestRequestStringUint64NullableArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint64NullableArray", + OperationName: "TestRequestStringUint16NullableArray", OperationSummary: "", - OperationID: "test_request_string_uint64_nullable_array", + OperationID: "test_request_string_uint16_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint64 + Request = []NilStringUint16 Params = struct{} Response = *Error ) @@ -65445,12 +65454,12 @@ func (s *Server) handleTestRequestStringUint64NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint64NullableArray(ctx, request) + response, err = s.h.TestRequestStringUint16NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint64NullableArray(ctx, request) + response, err = s.h.TestRequestStringUint16NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -65458,7 +65467,7 @@ func (s *Server) handleTestRequestStringUint64NullableArrayRequest(args [0]strin return } - if err := encodeTestRequestStringUint64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint16NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65467,18 +65476,18 @@ func (s *Server) handleTestRequestStringUint64NullableArrayRequest(args [0]strin } } -// handleTestRequestStringUint64NullableArrayArrayRequest handles test_request_string_uint64_nullable_array_array operation. +// handleTestRequestStringUint16NullableArrayArrayRequest handles test_request_string_uint16_nullable_array_array operation. // -// POST /test_request_string_uint64_nullable_array_array -func (s *Server) handleTestRequestStringUint64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint16_nullable_array_array +func (s *Server) handleTestRequestStringUint16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint64_nullable_array_array"), + otelogen.OperationID("test_request_string_uint16_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint16_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint16NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65503,11 +65512,11 @@ func (s *Server) handleTestRequestStringUint64NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint64NullableArrayArray", - ID: "test_request_string_uint64_nullable_array_array", + Name: "TestRequestStringUint16NullableArrayArray", + ID: "test_request_string_uint16_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUint64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint16NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65527,16 +65536,16 @@ func (s *Server) handleTestRequestStringUint64NullableArrayArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint64NullableArrayArray", + OperationName: "TestRequestStringUint16NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint64_nullable_array_array", + OperationID: "test_request_string_uint16_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint64 + Request = [][]NilStringUint16 Params = struct{} Response = *Error ) @@ -65549,12 +65558,12 @@ func (s *Server) handleTestRequestStringUint64NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint16NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint64NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint16NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -65562,7 +65571,7 @@ func (s *Server) handleTestRequestStringUint64NullableArrayArrayRequest(args [0] return } - if err := encodeTestRequestStringUint64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint16NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65571,18 +65580,18 @@ func (s *Server) handleTestRequestStringUint64NullableArrayArrayRequest(args [0] } } -// handleTestRequestStringUint8Request handles test_request_string_uint8 operation. +// handleTestRequestStringUint32Request handles test_request_string_uint32 operation. // -// POST /test_request_string_uint8 -func (s *Server) handleTestRequestStringUint8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint32 +func (s *Server) handleTestRequestStringUint32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint8"), + otelogen.OperationID("test_request_string_uint32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint8"), + semconv.HTTPRouteKey.String("/test_request_string_uint32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65607,11 +65616,11 @@ func (s *Server) handleTestRequestStringUint8Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint8", - ID: "test_request_string_uint8", + Name: "TestRequestStringUint32", + ID: "test_request_string_uint32", } ) - request, close, err := s.decodeTestRequestStringUint8Request(r) + request, close, err := s.decodeTestRequestStringUint32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65631,16 +65640,16 @@ func (s *Server) handleTestRequestStringUint8Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint8", + OperationName: "TestRequestStringUint32", OperationSummary: "", - OperationID: "test_request_string_uint8", + OperationID: "test_request_string_uint32", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUint8 + Request = OptStringUint32 Params = struct{} Response = *Error ) @@ -65653,12 +65662,12 @@ func (s *Server) handleTestRequestStringUint8Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint8(ctx, request) + response, err = s.h.TestRequestStringUint32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint8(ctx, request) + response, err = s.h.TestRequestStringUint32(ctx, request) } if err != nil { recordError("Internal", err) @@ -65666,7 +65675,7 @@ func (s *Server) handleTestRequestStringUint8Request(args [0]string, argsEscaped return } - if err := encodeTestRequestStringUint8Response(response, w, span); err != nil { + if err := encodeTestRequestStringUint32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65675,18 +65684,18 @@ func (s *Server) handleTestRequestStringUint8Request(args [0]string, argsEscaped } } -// handleTestRequestStringUint8ArrayRequest handles test_request_string_uint8_array operation. +// handleTestRequestStringUint32ArrayRequest handles test_request_string_uint32_array operation. // -// POST /test_request_string_uint8_array -func (s *Server) handleTestRequestStringUint8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint32_array +func (s *Server) handleTestRequestStringUint32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint8_array"), + otelogen.OperationID("test_request_string_uint32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint8_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65711,11 +65720,11 @@ func (s *Server) handleTestRequestStringUint8ArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint8Array", - ID: "test_request_string_uint8_array", + Name: "TestRequestStringUint32Array", + ID: "test_request_string_uint32_array", } ) - request, close, err := s.decodeTestRequestStringUint8ArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65735,16 +65744,16 @@ func (s *Server) handleTestRequestStringUint8ArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint8Array", + OperationName: "TestRequestStringUint32Array", OperationSummary: "", - OperationID: "test_request_string_uint8_array", + OperationID: "test_request_string_uint32_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint8 + Request = []uint32 Params = struct{} Response = *Error ) @@ -65757,12 +65766,12 @@ func (s *Server) handleTestRequestStringUint8ArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint8Array(ctx, request) + response, err = s.h.TestRequestStringUint32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint8Array(ctx, request) + response, err = s.h.TestRequestStringUint32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -65770,7 +65779,7 @@ func (s *Server) handleTestRequestStringUint8ArrayRequest(args [0]string, argsEs return } - if err := encodeTestRequestStringUint8ArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65779,18 +65788,18 @@ func (s *Server) handleTestRequestStringUint8ArrayRequest(args [0]string, argsEs } } -// handleTestRequestStringUint8ArrayArrayRequest handles test_request_string_uint8_array_array operation. +// handleTestRequestStringUint32ArrayArrayRequest handles test_request_string_uint32_array_array operation. // -// POST /test_request_string_uint8_array_array -func (s *Server) handleTestRequestStringUint8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint32_array_array +func (s *Server) handleTestRequestStringUint32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint8_array_array"), + otelogen.OperationID("test_request_string_uint32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint8_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65815,11 +65824,11 @@ func (s *Server) handleTestRequestStringUint8ArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint8ArrayArray", - ID: "test_request_string_uint8_array_array", + Name: "TestRequestStringUint32ArrayArray", + ID: "test_request_string_uint32_array_array", } ) - request, close, err := s.decodeTestRequestStringUint8ArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65839,16 +65848,16 @@ func (s *Server) handleTestRequestStringUint8ArrayArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint8ArrayArray", + OperationName: "TestRequestStringUint32ArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint8_array_array", + OperationID: "test_request_string_uint32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint8 + Request = [][]uint32 Params = struct{} Response = *Error ) @@ -65861,12 +65870,12 @@ func (s *Server) handleTestRequestStringUint8ArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint8ArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint8ArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -65874,7 +65883,7 @@ func (s *Server) handleTestRequestStringUint8ArrayArrayRequest(args [0]string, a return } - if err := encodeTestRequestStringUint8ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65883,18 +65892,18 @@ func (s *Server) handleTestRequestStringUint8ArrayArrayRequest(args [0]string, a } } -// handleTestRequestStringUint8NullableRequest handles test_request_string_uint8_nullable operation. +// handleTestRequestStringUint32NullableRequest handles test_request_string_uint32_nullable operation. // -// POST /test_request_string_uint8_nullable -func (s *Server) handleTestRequestStringUint8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint32_nullable +func (s *Server) handleTestRequestStringUint32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint8_nullable"), + otelogen.OperationID("test_request_string_uint32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint8_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_uint32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -65919,11 +65928,11 @@ func (s *Server) handleTestRequestStringUint8NullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint8Nullable", - ID: "test_request_string_uint8_nullable", + Name: "TestRequestStringUint32Nullable", + ID: "test_request_string_uint32_nullable", } ) - request, close, err := s.decodeTestRequestStringUint8NullableRequest(r) + request, close, err := s.decodeTestRequestStringUint32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -65943,16 +65952,16 @@ func (s *Server) handleTestRequestStringUint8NullableRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint8Nullable", + OperationName: "TestRequestStringUint32Nullable", OperationSummary: "", - OperationID: "test_request_string_uint8_nullable", + OperationID: "test_request_string_uint32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUint8 + Request = OptNilStringUint32 Params = struct{} Response = *Error ) @@ -65965,12 +65974,12 @@ func (s *Server) handleTestRequestStringUint8NullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint8Nullable(ctx, request) + response, err = s.h.TestRequestStringUint32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint8Nullable(ctx, request) + response, err = s.h.TestRequestStringUint32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -65978,7 +65987,7 @@ func (s *Server) handleTestRequestStringUint8NullableRequest(args [0]string, arg return } - if err := encodeTestRequestStringUint8NullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -65987,18 +65996,18 @@ func (s *Server) handleTestRequestStringUint8NullableRequest(args [0]string, arg } } -// handleTestRequestStringUint8NullableArrayRequest handles test_request_string_uint8_nullable_array operation. +// handleTestRequestStringUint32NullableArrayRequest handles test_request_string_uint32_nullable_array operation. // -// POST /test_request_string_uint8_nullable_array -func (s *Server) handleTestRequestStringUint8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint32_nullable_array +func (s *Server) handleTestRequestStringUint32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint8_nullable_array"), + otelogen.OperationID("test_request_string_uint32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint8_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66023,11 +66032,11 @@ func (s *Server) handleTestRequestStringUint8NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint8NullableArray", - ID: "test_request_string_uint8_nullable_array", + Name: "TestRequestStringUint32NullableArray", + ID: "test_request_string_uint32_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUint8NullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66047,16 +66056,16 @@ func (s *Server) handleTestRequestStringUint8NullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint8NullableArray", + OperationName: "TestRequestStringUint32NullableArray", OperationSummary: "", - OperationID: "test_request_string_uint8_nullable_array", + OperationID: "test_request_string_uint32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint8 + Request = []NilStringUint32 Params = struct{} Response = *Error ) @@ -66069,12 +66078,12 @@ func (s *Server) handleTestRequestStringUint8NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint8NullableArray(ctx, request) + response, err = s.h.TestRequestStringUint32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint8NullableArray(ctx, request) + response, err = s.h.TestRequestStringUint32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -66082,7 +66091,7 @@ func (s *Server) handleTestRequestStringUint8NullableArrayRequest(args [0]string return } - if err := encodeTestRequestStringUint8NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66091,18 +66100,18 @@ func (s *Server) handleTestRequestStringUint8NullableArrayRequest(args [0]string } } -// handleTestRequestStringUint8NullableArrayArrayRequest handles test_request_string_uint8_nullable_array_array operation. +// handleTestRequestStringUint32NullableArrayArrayRequest handles test_request_string_uint32_nullable_array_array operation. // -// POST /test_request_string_uint8_nullable_array_array -func (s *Server) handleTestRequestStringUint8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint32_nullable_array_array +func (s *Server) handleTestRequestStringUint32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint8_nullable_array_array"), + otelogen.OperationID("test_request_string_uint32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint8_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66127,11 +66136,11 @@ func (s *Server) handleTestRequestStringUint8NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUint8NullableArrayArray", - ID: "test_request_string_uint8_nullable_array_array", + Name: "TestRequestStringUint32NullableArrayArray", + ID: "test_request_string_uint32_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUint8NullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66151,16 +66160,16 @@ func (s *Server) handleTestRequestStringUint8NullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUint8NullableArrayArray", + OperationName: "TestRequestStringUint32NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint8_nullable_array_array", + OperationID: "test_request_string_uint32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint8 + Request = [][]NilStringUint32 Params = struct{} Response = *Error ) @@ -66173,12 +66182,12 @@ func (s *Server) handleTestRequestStringUint8NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUint8NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUint8NullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -66186,7 +66195,7 @@ func (s *Server) handleTestRequestStringUint8NullableArrayArrayRequest(args [0]s return } - if err := encodeTestRequestStringUint8NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66195,18 +66204,18 @@ func (s *Server) handleTestRequestStringUint8NullableArrayArrayRequest(args [0]s } } -// handleTestRequestStringUintArrayRequest handles test_request_string_uint_array operation. +// handleTestRequestStringUint64Request handles test_request_string_uint64 operation. // -// POST /test_request_string_uint_array -func (s *Server) handleTestRequestStringUintArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint64 +func (s *Server) handleTestRequestStringUint64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint_array"), + otelogen.OperationID("test_request_string_uint64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUintArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66231,11 +66240,11 @@ func (s *Server) handleTestRequestStringUintArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUintArray", - ID: "test_request_string_uint_array", + Name: "TestRequestStringUint64", + ID: "test_request_string_uint64", } ) - request, close, err := s.decodeTestRequestStringUintArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66255,16 +66264,16 @@ func (s *Server) handleTestRequestStringUintArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUintArray", + OperationName: "TestRequestStringUint64", OperationSummary: "", - OperationID: "test_request_string_uint_array", + OperationID: "test_request_string_uint64", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []uint + Request = OptStringUint64 Params = struct{} Response = *Error ) @@ -66277,12 +66286,12 @@ func (s *Server) handleTestRequestStringUintArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUintArray(ctx, request) + response, err = s.h.TestRequestStringUint64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUintArray(ctx, request) + response, err = s.h.TestRequestStringUint64(ctx, request) } if err != nil { recordError("Internal", err) @@ -66290,7 +66299,7 @@ func (s *Server) handleTestRequestStringUintArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringUintArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66299,18 +66308,18 @@ func (s *Server) handleTestRequestStringUintArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringUintArrayArrayRequest handles test_request_string_uint_array_array operation. +// handleTestRequestStringUint64ArrayRequest handles test_request_string_uint64_array operation. // -// POST /test_request_string_uint_array_array -func (s *Server) handleTestRequestStringUintArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint64_array +func (s *Server) handleTestRequestStringUint64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint_array_array"), + otelogen.OperationID("test_request_string_uint64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUintArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66335,11 +66344,11 @@ func (s *Server) handleTestRequestStringUintArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUintArrayArray", - ID: "test_request_string_uint_array_array", + Name: "TestRequestStringUint64Array", + ID: "test_request_string_uint64_array", } ) - request, close, err := s.decodeTestRequestStringUintArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66359,16 +66368,16 @@ func (s *Server) handleTestRequestStringUintArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUintArrayArray", + OperationName: "TestRequestStringUint64Array", OperationSummary: "", - OperationID: "test_request_string_uint_array_array", + OperationID: "test_request_string_uint64_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]uint + Request = []uint64 Params = struct{} Response = *Error ) @@ -66381,12 +66390,12 @@ func (s *Server) handleTestRequestStringUintArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUintArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUintArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -66394,7 +66403,7 @@ func (s *Server) handleTestRequestStringUintArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringUintArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66403,18 +66412,18 @@ func (s *Server) handleTestRequestStringUintArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringUintNullableRequest handles test_request_string_uint_nullable operation. +// handleTestRequestStringUint64ArrayArrayRequest handles test_request_string_uint64_array_array operation. // -// POST /test_request_string_uint_nullable -func (s *Server) handleTestRequestStringUintNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint64_array_array +func (s *Server) handleTestRequestStringUint64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint_nullable"), + otelogen.OperationID("test_request_string_uint64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_uint64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUintNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66439,11 +66448,11 @@ func (s *Server) handleTestRequestStringUintNullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUintNullable", - ID: "test_request_string_uint_nullable", + Name: "TestRequestStringUint64ArrayArray", + ID: "test_request_string_uint64_array_array", } ) - request, close, err := s.decodeTestRequestStringUintNullableRequest(r) + request, close, err := s.decodeTestRequestStringUint64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66463,16 +66472,16 @@ func (s *Server) handleTestRequestStringUintNullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUintNullable", + OperationName: "TestRequestStringUint64ArrayArray", OperationSummary: "", - OperationID: "test_request_string_uint_nullable", + OperationID: "test_request_string_uint64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUint + Request = [][]uint64 Params = struct{} Response = *Error ) @@ -66485,12 +66494,12 @@ func (s *Server) handleTestRequestStringUintNullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUintNullable(ctx, request) + response, err = s.h.TestRequestStringUint64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUintNullable(ctx, request) + response, err = s.h.TestRequestStringUint64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -66498,7 +66507,7 @@ func (s *Server) handleTestRequestStringUintNullableRequest(args [0]string, args return } - if err := encodeTestRequestStringUintNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66507,18 +66516,18 @@ func (s *Server) handleTestRequestStringUintNullableRequest(args [0]string, args } } -// handleTestRequestStringUintNullableArrayRequest handles test_request_string_uint_nullable_array operation. +// handleTestRequestStringUint64NullableRequest handles test_request_string_uint64_nullable operation. // -// POST /test_request_string_uint_nullable_array -func (s *Server) handleTestRequestStringUintNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint64_nullable +func (s *Server) handleTestRequestStringUint64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint_nullable_array"), + otelogen.OperationID("test_request_string_uint64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUintNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66543,11 +66552,11 @@ func (s *Server) handleTestRequestStringUintNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUintNullableArray", - ID: "test_request_string_uint_nullable_array", + Name: "TestRequestStringUint64Nullable", + ID: "test_request_string_uint64_nullable", } ) - request, close, err := s.decodeTestRequestStringUintNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66567,16 +66576,16 @@ func (s *Server) handleTestRequestStringUintNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUintNullableArray", + OperationName: "TestRequestStringUint64Nullable", OperationSummary: "", - OperationID: "test_request_string_uint_nullable_array", + OperationID: "test_request_string_uint64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUint + Request = OptNilStringUint64 Params = struct{} Response = *Error ) @@ -66589,12 +66598,12 @@ func (s *Server) handleTestRequestStringUintNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUintNullableArray(ctx, request) + response, err = s.h.TestRequestStringUint64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUintNullableArray(ctx, request) + response, err = s.h.TestRequestStringUint64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -66602,7 +66611,7 @@ func (s *Server) handleTestRequestStringUintNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUintNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66611,18 +66620,18 @@ func (s *Server) handleTestRequestStringUintNullableArrayRequest(args [0]string, } } -// handleTestRequestStringUintNullableArrayArrayRequest handles test_request_string_uint_nullable_array_array operation. +// handleTestRequestStringUint64NullableArrayRequest handles test_request_string_uint64_nullable_array operation. // -// POST /test_request_string_uint_nullable_array_array -func (s *Server) handleTestRequestStringUintNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint64_nullable_array +func (s *Server) handleTestRequestStringUint64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_uint_nullable_array_array"), + otelogen.OperationID("test_request_string_uint64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_uint_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUintNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66647,11 +66656,11 @@ func (s *Server) handleTestRequestStringUintNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUintNullableArrayArray", - ID: "test_request_string_uint_nullable_array_array", + Name: "TestRequestStringUint64NullableArray", + ID: "test_request_string_uint64_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUintNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66671,16 +66680,16 @@ func (s *Server) handleTestRequestStringUintNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUintNullableArrayArray", + OperationName: "TestRequestStringUint64NullableArray", OperationSummary: "", - OperationID: "test_request_string_uint_nullable_array_array", + OperationID: "test_request_string_uint64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUint + Request = []NilStringUint64 Params = struct{} Response = *Error ) @@ -66693,12 +66702,12 @@ func (s *Server) handleTestRequestStringUintNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUintNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUintNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -66706,7 +66715,7 @@ func (s *Server) handleTestRequestStringUintNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringUintNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66715,18 +66724,18 @@ func (s *Server) handleTestRequestStringUintNullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringUnixRequest handles test_request_string_unix operation. +// handleTestRequestStringUint64NullableArrayArrayRequest handles test_request_string_uint64_nullable_array_array operation. // -// POST /test_request_string_unix -func (s *Server) handleTestRequestStringUnixRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint64_nullable_array_array +func (s *Server) handleTestRequestStringUint64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix"), + otelogen.OperationID("test_request_string_uint64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix"), + semconv.HTTPRouteKey.String("/test_request_string_uint64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnix", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66751,11 +66760,11 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnix", - ID: "test_request_string_unix", + Name: "TestRequestStringUint64NullableArrayArray", + ID: "test_request_string_uint64_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixRequest(r) + request, close, err := s.decodeTestRequestStringUint64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66775,16 +66784,16 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnix", + OperationName: "TestRequestStringUint64NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix", + OperationID: "test_request_string_uint64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUnixSeconds + Request = [][]NilStringUint64 Params = struct{} Response = *Error ) @@ -66797,12 +66806,12 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnix(ctx, request) + response, err = s.h.TestRequestStringUint64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnix(ctx, request) + response, err = s.h.TestRequestStringUint64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -66810,7 +66819,7 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, argsEscaped return } - if err := encodeTestRequestStringUnixResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66819,18 +66828,18 @@ func (s *Server) handleTestRequestStringUnixRequest(args [0]string, argsEscaped } } -// handleTestRequestStringUnixArrayRequest handles test_request_string_unix_array operation. +// handleTestRequestStringUint8Request handles test_request_string_uint8 operation. // -// POST /test_request_string_unix_array -func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint8 +func (s *Server) handleTestRequestStringUint8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_array"), + otelogen.OperationID("test_request_string_uint8"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint8"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66855,11 +66864,11 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixArray", - ID: "test_request_string_unix_array", + Name: "TestRequestStringUint8", + ID: "test_request_string_uint8", } ) - request, close, err := s.decodeTestRequestStringUnixArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint8Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66879,16 +66888,16 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixArray", + OperationName: "TestRequestStringUint8", OperationSummary: "", - OperationID: "test_request_string_unix_array", + OperationID: "test_request_string_uint8", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = OptStringUint8 Params = struct{} Response = *Error ) @@ -66901,12 +66910,12 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixArray(ctx, request) + response, err = s.h.TestRequestStringUint8(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixArray(ctx, request) + response, err = s.h.TestRequestStringUint8(ctx, request) } if err != nil { recordError("Internal", err) @@ -66914,7 +66923,7 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringUnixArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint8Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -66923,18 +66932,18 @@ func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, argsEsc } } -// handleTestRequestStringUnixArrayArrayRequest handles test_request_string_unix_array_array operation. +// handleTestRequestStringUint8ArrayRequest handles test_request_string_uint8_array operation. // -// POST /test_request_string_unix_array_array -func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint8_array +func (s *Server) handleTestRequestStringUint8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_array_array"), + otelogen.OperationID("test_request_string_uint8_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint8_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -66959,11 +66968,11 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixArrayArray", - ID: "test_request_string_unix_array_array", + Name: "TestRequestStringUint8Array", + ID: "test_request_string_uint8_array", } ) - request, close, err := s.decodeTestRequestStringUnixArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint8ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -66983,16 +66992,16 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixArrayArray", + OperationName: "TestRequestStringUint8Array", OperationSummary: "", - OperationID: "test_request_string_unix_array_array", + OperationID: "test_request_string_uint8_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = []uint8 Params = struct{} Response = *Error ) @@ -67005,12 +67014,12 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint8Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint8Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -67018,7 +67027,7 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringUnixArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint8ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67027,18 +67036,18 @@ func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, ar } } -// handleTestRequestStringUnixMicroRequest handles test_request_string_unix-micro operation. +// handleTestRequestStringUint8ArrayArrayRequest handles test_request_string_uint8_array_array operation. // -// POST /test_request_string_unix-micro -func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint8_array_array +func (s *Server) handleTestRequestStringUint8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro"), + otelogen.OperationID("test_request_string_uint8_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-micro"), + semconv.HTTPRouteKey.String("/test_request_string_uint8_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicro", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67063,11 +67072,11 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicro", - ID: "test_request_string_unix-micro", + Name: "TestRequestStringUint8ArrayArray", + ID: "test_request_string_uint8_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroRequest(r) + request, close, err := s.decodeTestRequestStringUint8ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67087,16 +67096,16 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicro", + OperationName: "TestRequestStringUint8ArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-micro", + OperationID: "test_request_string_uint8_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUnixMicro + Request = [][]uint8 Params = struct{} Response = *Error ) @@ -67109,12 +67118,12 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMicro(ctx, request) + response, err = s.h.TestRequestStringUint8ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMicro(ctx, request) + response, err = s.h.TestRequestStringUint8ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -67122,7 +67131,7 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringUnixMicroResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint8ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67131,18 +67140,18 @@ func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, argsEsc } } -// handleTestRequestStringUnixMicroArrayRequest handles test_request_string_unix-micro_array operation. +// handleTestRequestStringUint8NullableRequest handles test_request_string_uint8_nullable operation. // -// POST /test_request_string_unix-micro_array -func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint8_nullable +func (s *Server) handleTestRequestStringUint8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_array"), + otelogen.OperationID("test_request_string_uint8_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-micro_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint8_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67167,11 +67176,11 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroArray", - ID: "test_request_string_unix-micro_array", + Name: "TestRequestStringUint8Nullable", + ID: "test_request_string_uint8_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixMicroArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint8NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67191,16 +67200,16 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroArray", + OperationName: "TestRequestStringUint8Nullable", OperationSummary: "", - OperationID: "test_request_string_unix-micro_array", + OperationID: "test_request_string_uint8_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = OptNilStringUint8 Params = struct{} Response = *Error ) @@ -67213,12 +67222,12 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMicroArray(ctx, request) + response, err = s.h.TestRequestStringUint8Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMicroArray(ctx, request) + response, err = s.h.TestRequestStringUint8Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -67226,7 +67235,7 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringUnixMicroArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint8NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67235,18 +67244,18 @@ func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, ar } } -// handleTestRequestStringUnixMicroArrayArrayRequest handles test_request_string_unix-micro_array_array operation. +// handleTestRequestStringUint8NullableArrayRequest handles test_request_string_uint8_nullable_array operation. // -// POST /test_request_string_unix-micro_array_array -func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint8_nullable_array +func (s *Server) handleTestRequestStringUint8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_array_array"), + otelogen.OperationID("test_request_string_uint8_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-micro_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint8_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67271,11 +67280,11 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroArrayArray", - ID: "test_request_string_unix-micro_array_array", + Name: "TestRequestStringUint8NullableArray", + ID: "test_request_string_uint8_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUint8NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67295,16 +67304,16 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroArrayArray", + OperationName: "TestRequestStringUint8NullableArray", OperationSummary: "", - OperationID: "test_request_string_unix-micro_array_array", + OperationID: "test_request_string_uint8_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = []NilStringUint8 Params = struct{} Response = *Error ) @@ -67317,12 +67326,12 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint8NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMicroArrayArray(ctx, request) + response, err = s.h.TestRequestStringUint8NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -67330,7 +67339,7 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin return } - if err := encodeTestRequestStringUnixMicroArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint8NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67339,18 +67348,18 @@ func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]strin } } -// handleTestRequestStringUnixMicroNullableRequest handles test_request_string_unix-micro_nullable operation. +// handleTestRequestStringUint8NullableArrayArrayRequest handles test_request_string_uint8_nullable_array_array operation. // -// POST /test_request_string_unix-micro_nullable -func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint8_nullable_array_array +func (s *Server) handleTestRequestStringUint8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable"), + otelogen.OperationID("test_request_string_uint8_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-micro_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_uint8_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUint8NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67375,11 +67384,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroNullable", - ID: "test_request_string_unix-micro_nullable", + Name: "TestRequestStringUint8NullableArrayArray", + ID: "test_request_string_uint8_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroNullableRequest(r) + request, close, err := s.decodeTestRequestStringUint8NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67399,16 +67408,16 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroNullable", + OperationName: "TestRequestStringUint8NullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-micro_nullable", + OperationID: "test_request_string_uint8_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUnixMicro + Request = [][]NilStringUint8 Params = struct{} Response = *Error ) @@ -67421,12 +67430,12 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestStringUint8NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMicroNullable(ctx, request) + response, err = s.h.TestRequestStringUint8NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -67434,7 +67443,7 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, return } - if err := encodeTestRequestStringUnixMicroNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUint8NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67443,18 +67452,18 @@ func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, } } -// handleTestRequestStringUnixMicroNullableArrayRequest handles test_request_string_unix-micro_nullable_array operation. +// handleTestRequestStringUintArrayRequest handles test_request_string_uint_array operation. // -// POST /test_request_string_unix-micro_nullable_array -func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint_array +func (s *Server) handleTestRequestStringUintArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable_array"), + otelogen.OperationID("test_request_string_uint_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-micro_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUintArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67479,11 +67488,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroNullableArray", - ID: "test_request_string_unix-micro_nullable_array", + Name: "TestRequestStringUintArray", + ID: "test_request_string_uint_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUintArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67503,16 +67512,16 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroNullableArray", + OperationName: "TestRequestStringUintArray", OperationSummary: "", - OperationID: "test_request_string_unix-micro_nullable_array", + OperationID: "test_request_string_uint_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixMicro + Request = []uint Params = struct{} Response = *Error ) @@ -67525,12 +67534,12 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestStringUintArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMicroNullableArray(ctx, request) + response, err = s.h.TestRequestStringUintArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -67538,7 +67547,7 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st return } - if err := encodeTestRequestStringUnixMicroNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUintArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67547,18 +67556,18 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]st } } -// handleTestRequestStringUnixMicroNullableArrayArrayRequest handles test_request_string_unix-micro_nullable_array_array operation. +// handleTestRequestStringUintArrayArrayRequest handles test_request_string_uint_array_array operation. // -// POST /test_request_string_unix-micro_nullable_array_array -func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint_array_array +func (s *Server) handleTestRequestStringUintArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-micro_nullable_array_array"), + otelogen.OperationID("test_request_string_uint_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-micro_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint_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(), "TestRequestStringUintArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67583,11 +67592,11 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMicroNullableArrayArray", - ID: "test_request_string_unix-micro_nullable_array_array", + Name: "TestRequestStringUintArrayArray", + ID: "test_request_string_uint_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUintArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67607,16 +67616,16 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMicroNullableArrayArray", + OperationName: "TestRequestStringUintArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-micro_nullable_array_array", + OperationID: "test_request_string_uint_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixMicro + Request = [][]uint Params = struct{} Response = *Error ) @@ -67629,12 +67638,12 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUintArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUintArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -67642,7 +67651,7 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args return } - if err := encodeTestRequestStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUintArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67651,18 +67660,18 @@ func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args } } -// handleTestRequestStringUnixMilliRequest handles test_request_string_unix-milli operation. +// handleTestRequestStringUintNullableRequest handles test_request_string_uint_nullable operation. // -// POST /test_request_string_unix-milli -func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint_nullable +func (s *Server) handleTestRequestStringUintNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli"), + otelogen.OperationID("test_request_string_uint_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-milli"), + semconv.HTTPRouteKey.String("/test_request_string_uint_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilli", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUintNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67687,11 +67696,11 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilli", - ID: "test_request_string_unix-milli", + Name: "TestRequestStringUintNullable", + ID: "test_request_string_uint_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixMilliRequest(r) + request, close, err := s.decodeTestRequestStringUintNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67711,16 +67720,16 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, argsEsc if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilli", + OperationName: "TestRequestStringUintNullable", OperationSummary: "", - OperationID: "test_request_string_unix-milli", + OperationID: "test_request_string_uint_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUnixMilli + Request = OptNilStringUint Params = struct{} Response = *Error ) @@ -67733,12 +67742,12 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMilli(ctx, request) + response, err = s.h.TestRequestStringUintNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMilli(ctx, request) + response, err = s.h.TestRequestStringUintNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -67746,7 +67755,7 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, argsEsc return } - if err := encodeTestRequestStringUnixMilliResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUintNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67755,18 +67764,18 @@ func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, argsEsc } } -// handleTestRequestStringUnixMilliArrayRequest handles test_request_string_unix-milli_array operation. +// handleTestRequestStringUintNullableArrayRequest handles test_request_string_uint_nullable_array operation. // -// POST /test_request_string_unix-milli_array -func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint_nullable_array +func (s *Server) handleTestRequestStringUintNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_array"), + otelogen.OperationID("test_request_string_uint_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-milli_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint_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(), "TestRequestStringUintNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67791,11 +67800,11 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliArray", - ID: "test_request_string_unix-milli_array", + Name: "TestRequestStringUintNullableArray", + ID: "test_request_string_uint_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliArrayRequest(r) + request, close, err := s.decodeTestRequestStringUintNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67815,16 +67824,16 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, ar if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliArray", + OperationName: "TestRequestStringUintNullableArray", OperationSummary: "", - OperationID: "test_request_string_unix-milli_array", + OperationID: "test_request_string_uint_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = []NilStringUint Params = struct{} Response = *Error ) @@ -67837,12 +67846,12 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMilliArray(ctx, request) + response, err = s.h.TestRequestStringUintNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMilliArray(ctx, request) + response, err = s.h.TestRequestStringUintNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -67850,7 +67859,7 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, ar return } - if err := encodeTestRequestStringUnixMilliArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUintNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67859,18 +67868,18 @@ func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, ar } } -// handleTestRequestStringUnixMilliArrayArrayRequest handles test_request_string_unix-milli_array_array operation. +// handleTestRequestStringUintNullableArrayArrayRequest handles test_request_string_uint_nullable_array_array operation. // -// POST /test_request_string_unix-milli_array_array -func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_uint_nullable_array_array +func (s *Server) handleTestRequestStringUintNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_array_array"), + otelogen.OperationID("test_request_string_uint_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-milli_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_uint_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(), "TestRequestStringUintNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67895,11 +67904,11 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliArrayArray", - ID: "test_request_string_unix-milli_array_array", + Name: "TestRequestStringUintNullableArrayArray", + ID: "test_request_string_uint_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUintNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -67919,16 +67928,16 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliArrayArray", + OperationName: "TestRequestStringUintNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-milli_array_array", + OperationID: "test_request_string_uint_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilStringUint Params = struct{} Response = *Error ) @@ -67941,12 +67950,12 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestStringUintNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMilliArrayArray(ctx, request) + response, err = s.h.TestRequestStringUintNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -67954,7 +67963,7 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin return } - if err := encodeTestRequestStringUnixMilliArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUintNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -67963,18 +67972,18 @@ func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]strin } } -// handleTestRequestStringUnixMilliNullableRequest handles test_request_string_unix-milli_nullable operation. +// handleTestRequestStringUnixRequest handles test_request_string_unix operation. // -// POST /test_request_string_unix-milli_nullable -func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix +func (s *Server) handleTestRequestStringUnixRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable"), + otelogen.OperationID("test_request_string_unix"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-milli_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_unix"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnix", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -67999,11 +68008,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliNullable", - ID: "test_request_string_unix-milli_nullable", + Name: "TestRequestStringUnix", + ID: "test_request_string_unix", } ) - request, close, err := s.decodeTestRequestStringUnixMilliNullableRequest(r) + request, close, err := s.decodeTestRequestStringUnixRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68023,16 +68032,16 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliNullable", + OperationName: "TestRequestStringUnix", OperationSummary: "", - OperationID: "test_request_string_unix-milli_nullable", + OperationID: "test_request_string_unix", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUnixMilli + Request = OptStringUnixSeconds Params = struct{} Response = *Error ) @@ -68045,12 +68054,12 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestStringUnix(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMilliNullable(ctx, request) + response, err = s.h.TestRequestStringUnix(ctx, request) } if err != nil { recordError("Internal", err) @@ -68058,7 +68067,7 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, return } - if err := encodeTestRequestStringUnixMilliNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68067,18 +68076,18 @@ func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, } } -// handleTestRequestStringUnixMilliNullableArrayRequest handles test_request_string_unix-milli_nullable_array operation. +// handleTestRequestStringUnixArrayRequest handles test_request_string_unix_array operation. // -// POST /test_request_string_unix-milli_nullable_array -func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix_array +func (s *Server) handleTestRequestStringUnixArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable_array"), + otelogen.OperationID("test_request_string_unix_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-milli_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68103,11 +68112,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliNullableArray", - ID: "test_request_string_unix-milli_nullable_array", + Name: "TestRequestStringUnixArray", + ID: "test_request_string_unix_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68127,16 +68136,16 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliNullableArray", + OperationName: "TestRequestStringUnixArray", OperationSummary: "", - OperationID: "test_request_string_unix-milli_nullable_array", + OperationID: "test_request_string_unix_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixMilli + Request = []time.Time Params = struct{} Response = *Error ) @@ -68149,12 +68158,12 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMilliNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -68162,7 +68171,7 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st return } - if err := encodeTestRequestStringUnixMilliNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68171,18 +68180,18 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]st } } -// handleTestRequestStringUnixMilliNullableArrayArrayRequest handles test_request_string_unix-milli_nullable_array_array operation. +// handleTestRequestStringUnixArrayArrayRequest handles test_request_string_unix_array_array operation. // -// POST /test_request_string_unix-milli_nullable_array_array -func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix_array_array +func (s *Server) handleTestRequestStringUnixArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-milli_nullable_array_array"), + otelogen.OperationID("test_request_string_unix_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-milli_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix_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(), "TestRequestStringUnixArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68207,11 +68216,11 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixMilliNullableArrayArray", - ID: "test_request_string_unix-milli_nullable_array_array", + Name: "TestRequestStringUnixArrayArray", + ID: "test_request_string_unix_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68231,16 +68240,16 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixMilliNullableArrayArray", + OperationName: "TestRequestStringUnixArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-milli_nullable_array_array", + OperationID: "test_request_string_unix_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixMilli + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -68253,12 +68262,12 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -68266,7 +68275,7 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args return } - if err := encodeTestRequestStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68275,18 +68284,18 @@ func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args } } -// handleTestRequestStringUnixNanoRequest handles test_request_string_unix-nano operation. +// handleTestRequestStringUnixMicroRequest handles test_request_string_unix-micro operation. // -// POST /test_request_string_unix-nano -func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-micro +func (s *Server) handleTestRequestStringUnixMicroRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano"), + otelogen.OperationID("test_request_string_unix-micro"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-nano"), + semconv.HTTPRouteKey.String("/test_request_string_unix-micro"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNano", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicro", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68311,11 +68320,11 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNano", - ID: "test_request_string_unix-nano", + Name: "TestRequestStringUnixMicro", + ID: "test_request_string_unix-micro", } ) - request, close, err := s.decodeTestRequestStringUnixNanoRequest(r) + request, close, err := s.decodeTestRequestStringUnixMicroRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68335,16 +68344,16 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, argsEsca if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNano", + OperationName: "TestRequestStringUnixMicro", OperationSummary: "", - OperationID: "test_request_string_unix-nano", + OperationID: "test_request_string_unix-micro", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUnixNano + Request = OptStringUnixMicro Params = struct{} Response = *Error ) @@ -68357,12 +68366,12 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNano(ctx, request) + response, err = s.h.TestRequestStringUnixMicro(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNano(ctx, request) + response, err = s.h.TestRequestStringUnixMicro(ctx, request) } if err != nil { recordError("Internal", err) @@ -68370,7 +68379,7 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, argsEsca return } - if err := encodeTestRequestStringUnixNanoResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMicroResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68379,18 +68388,18 @@ func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, argsEsca } } -// handleTestRequestStringUnixNanoArrayRequest handles test_request_string_unix-nano_array operation. +// handleTestRequestStringUnixMicroArrayRequest handles test_request_string_unix-micro_array operation. // -// POST /test_request_string_unix-nano_array -func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-micro_array +func (s *Server) handleTestRequestStringUnixMicroArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_array"), + otelogen.OperationID("test_request_string_unix-micro_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-nano_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-micro_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68415,11 +68424,11 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoArray", - ID: "test_request_string_unix-nano_array", + Name: "TestRequestStringUnixMicroArray", + ID: "test_request_string_unix-micro_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMicroArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68439,9 +68448,9 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoArray", + OperationName: "TestRequestStringUnixMicroArray", OperationSummary: "", - OperationID: "test_request_string_unix-nano_array", + OperationID: "test_request_string_unix-micro_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -68461,12 +68470,12 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNanoArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNanoArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -68474,7 +68483,7 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, arg return } - if err := encodeTestRequestStringUnixNanoArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMicroArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68483,18 +68492,18 @@ func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, arg } } -// handleTestRequestStringUnixNanoArrayArrayRequest handles test_request_string_unix-nano_array_array operation. +// handleTestRequestStringUnixMicroArrayArrayRequest handles test_request_string_unix-micro_array_array operation. // -// POST /test_request_string_unix-nano_array_array -func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-micro_array_array +func (s *Server) handleTestRequestStringUnixMicroArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_array_array"), + otelogen.OperationID("test_request_string_unix-micro_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-nano_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-micro_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(), "TestRequestStringUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68519,11 +68528,11 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoArrayArray", - ID: "test_request_string_unix-nano_array_array", + Name: "TestRequestStringUnixMicroArrayArray", + ID: "test_request_string_unix-micro_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMicroArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68543,9 +68552,9 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoArrayArray", + OperationName: "TestRequestStringUnixMicroArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-nano_array_array", + OperationID: "test_request_string_unix-micro_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -68565,12 +68574,12 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNanoArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -68578,7 +68587,7 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string return } - if err := encodeTestRequestStringUnixNanoArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMicroArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68587,18 +68596,18 @@ func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string } } -// handleTestRequestStringUnixNanoNullableRequest handles test_request_string_unix-nano_nullable operation. +// handleTestRequestStringUnixMicroNullableRequest handles test_request_string_unix-micro_nullable operation. // -// POST /test_request_string_unix-nano_nullable -func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-micro_nullable +func (s *Server) handleTestRequestStringUnixMicroNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable"), + otelogen.OperationID("test_request_string_unix-micro_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-nano_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_unix-micro_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMicroNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68623,11 +68632,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoNullable", - ID: "test_request_string_unix-nano_nullable", + Name: "TestRequestStringUnixMicroNullable", + ID: "test_request_string_unix-micro_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixNanoNullableRequest(r) + request, close, err := s.decodeTestRequestStringUnixMicroNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68647,16 +68656,16 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoNullable", + OperationName: "TestRequestStringUnixMicroNullable", OperationSummary: "", - OperationID: "test_request_string_unix-nano_nullable", + OperationID: "test_request_string_unix-micro_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUnixNano + Request = OptNilStringUnixMicro Params = struct{} Response = *Error ) @@ -68669,12 +68678,12 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNanoNullable(ctx, request) + response, err = s.h.TestRequestStringUnixMicroNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNanoNullable(ctx, request) + response, err = s.h.TestRequestStringUnixMicroNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -68682,7 +68691,7 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, return } - if err := encodeTestRequestStringUnixNanoNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMicroNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68691,18 +68700,18 @@ func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, } } -// handleTestRequestStringUnixNanoNullableArrayRequest handles test_request_string_unix-nano_nullable_array operation. +// handleTestRequestStringUnixMicroNullableArrayRequest handles test_request_string_unix-micro_nullable_array operation. // -// POST /test_request_string_unix-nano_nullable_array -func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-micro_nullable_array +func (s *Server) handleTestRequestStringUnixMicroNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable_array"), + otelogen.OperationID("test_request_string_unix-micro_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-nano_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-micro_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(), "TestRequestStringUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68727,11 +68736,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoNullableArray", - ID: "test_request_string_unix-nano_nullable_array", + Name: "TestRequestStringUnixMicroNullableArray", + ID: "test_request_string_unix-micro_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68751,16 +68760,16 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoNullableArray", + OperationName: "TestRequestStringUnixMicroNullableArray", OperationSummary: "", - OperationID: "test_request_string_unix-nano_nullable_array", + OperationID: "test_request_string_unix-micro_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixNano + Request = []NilStringUnixMicro Params = struct{} Response = *Error ) @@ -68773,12 +68782,12 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNanoNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -68786,7 +68795,7 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str return } - if err := encodeTestRequestStringUnixNanoNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMicroNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68795,18 +68804,18 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]str } } -// handleTestRequestStringUnixNanoNullableArrayArrayRequest handles test_request_string_unix-nano_nullable_array_array operation. +// handleTestRequestStringUnixMicroNullableArrayArrayRequest handles test_request_string_unix-micro_nullable_array_array operation. // -// POST /test_request_string_unix-nano_nullable_array_array -func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-micro_nullable_array_array +func (s *Server) handleTestRequestStringUnixMicroNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-nano_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-micro_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-nano_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-micro_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(), "TestRequestStringUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68831,11 +68840,11 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNanoNullableArrayArray", - ID: "test_request_string_unix-nano_nullable_array_array", + Name: "TestRequestStringUnixMicroNullableArrayArray", + ID: "test_request_string_unix-micro_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68855,16 +68864,16 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNanoNullableArrayArray", + OperationName: "TestRequestStringUnixMicroNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-nano_nullable_array_array", + OperationID: "test_request_string_unix-micro_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixNano + Request = [][]NilStringUnixMicro Params = struct{} Response = *Error ) @@ -68877,12 +68886,12 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMicroNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -68890,7 +68899,7 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ return } - if err := encodeTestRequestStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -68899,18 +68908,18 @@ func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [ } } -// handleTestRequestStringUnixNullableRequest handles test_request_string_unix_nullable operation. +// handleTestRequestStringUnixMilliRequest handles test_request_string_unix-milli operation. // -// POST /test_request_string_unix_nullable -func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-milli +func (s *Server) handleTestRequestStringUnixMilliRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable"), + otelogen.OperationID("test_request_string_unix-milli"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_unix-milli"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilli", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -68935,11 +68944,11 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNullable", - ID: "test_request_string_unix_nullable", + Name: "TestRequestStringUnixMilli", + ID: "test_request_string_unix-milli", } ) - request, close, err := s.decodeTestRequestStringUnixNullableRequest(r) + request, close, err := s.decodeTestRequestStringUnixMilliRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -68959,16 +68968,16 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, args if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNullable", + OperationName: "TestRequestStringUnixMilli", OperationSummary: "", - OperationID: "test_request_string_unix_nullable", + OperationID: "test_request_string_unix-milli", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUnixSeconds + Request = OptStringUnixMilli Params = struct{} Response = *Error ) @@ -68981,12 +68990,12 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNullable(ctx, request) + response, err = s.h.TestRequestStringUnixMilli(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNullable(ctx, request) + response, err = s.h.TestRequestStringUnixMilli(ctx, request) } if err != nil { recordError("Internal", err) @@ -68994,7 +69003,7 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, args return } - if err := encodeTestRequestStringUnixNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMilliResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69003,18 +69012,18 @@ func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, args } } -// handleTestRequestStringUnixNullableArrayRequest handles test_request_string_unix_nullable_array operation. +// handleTestRequestStringUnixMilliArrayRequest handles test_request_string_unix-milli_array operation. // -// POST /test_request_string_unix_nullable_array -func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-milli_array +func (s *Server) handleTestRequestStringUnixMilliArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable_array"), + otelogen.OperationID("test_request_string_unix-milli_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-milli_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69039,11 +69048,11 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNullableArray", - ID: "test_request_string_unix_nullable_array", + Name: "TestRequestStringUnixMilliArray", + ID: "test_request_string_unix-milli_array", } ) - request, close, err := s.decodeTestRequestStringUnixNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMilliArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69063,16 +69072,16 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNullableArray", + OperationName: "TestRequestStringUnixMilliArray", OperationSummary: "", - OperationID: "test_request_string_unix_nullable_array", + OperationID: "test_request_string_unix-milli_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixSeconds + Request = []time.Time Params = struct{} Response = *Error ) @@ -69085,12 +69094,12 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -69098,7 +69107,7 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUnixNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMilliArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69107,18 +69116,18 @@ func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, } } -// handleTestRequestStringUnixNullableArrayArrayRequest handles test_request_string_unix_nullable_array_array operation. +// handleTestRequestStringUnixMilliArrayArrayRequest handles test_request_string_unix-milli_array_array operation. // -// POST /test_request_string_unix_nullable_array_array -func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-milli_array_array +func (s *Server) handleTestRequestStringUnixMilliArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-milli_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-milli_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(), "TestRequestStringUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69143,11 +69152,11 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixNullableArrayArray", - ID: "test_request_string_unix_nullable_array_array", + Name: "TestRequestStringUnixMilliArrayArray", + ID: "test_request_string_unix-milli_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMilliArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69167,16 +69176,16 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixNullableArrayArray", + OperationName: "TestRequestStringUnixMilliArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix_nullable_array_array", + OperationID: "test_request_string_unix-milli_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixSeconds + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -69189,12 +69198,12 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -69202,7 +69211,7 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st return } - if err := encodeTestRequestStringUnixNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMilliArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69211,18 +69220,18 @@ func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]st } } -// handleTestRequestStringUnixSecondsRequest handles test_request_string_unix-seconds operation. +// handleTestRequestStringUnixMilliNullableRequest handles test_request_string_unix-milli_nullable operation. // -// POST /test_request_string_unix-seconds -func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-milli_nullable +func (s *Server) handleTestRequestStringUnixMilliNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds"), + otelogen.OperationID("test_request_string_unix-milli_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-seconds"), + semconv.HTTPRouteKey.String("/test_request_string_unix-milli_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSeconds", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixMilliNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69247,11 +69256,11 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSeconds", - ID: "test_request_string_unix-seconds", + Name: "TestRequestStringUnixMilliNullable", + ID: "test_request_string_unix-milli_nullable", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsRequest(r) + request, close, err := s.decodeTestRequestStringUnixMilliNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69271,16 +69280,16 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, argsE if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSeconds", + OperationName: "TestRequestStringUnixMilliNullable", OperationSummary: "", - OperationID: "test_request_string_unix-seconds", + OperationID: "test_request_string_unix-milli_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptStringUnixSeconds + Request = OptNilStringUnixMilli Params = struct{} Response = *Error ) @@ -69293,12 +69302,12 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixSeconds(ctx, request) + response, err = s.h.TestRequestStringUnixMilliNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixSeconds(ctx, request) + response, err = s.h.TestRequestStringUnixMilliNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -69306,7 +69315,7 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, argsE return } - if err := encodeTestRequestStringUnixSecondsResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMilliNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69315,18 +69324,18 @@ func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, argsE } } -// handleTestRequestStringUnixSecondsArrayRequest handles test_request_string_unix-seconds_array operation. +// handleTestRequestStringUnixMilliNullableArrayRequest handles test_request_string_unix-milli_nullable_array operation. // -// POST /test_request_string_unix-seconds_array -func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-milli_nullable_array +func (s *Server) handleTestRequestStringUnixMilliNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_array"), + otelogen.OperationID("test_request_string_unix-milli_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-milli_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(), "TestRequestStringUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69351,11 +69360,11 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsArray", - ID: "test_request_string_unix-seconds_array", + Name: "TestRequestStringUnixMilliNullableArray", + ID: "test_request_string_unix-milli_nullable_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69375,16 +69384,16 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsArray", + OperationName: "TestRequestStringUnixMilliNullableArray", OperationSummary: "", - OperationID: "test_request_string_unix-seconds_array", + OperationID: "test_request_string_unix-milli_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []time.Time + Request = []NilStringUnixMilli Params = struct{} Response = *Error ) @@ -69397,12 +69406,12 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixSecondsArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -69410,7 +69419,7 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, return } - if err := encodeTestRequestStringUnixSecondsArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMilliNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69419,18 +69428,18 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, } } -// handleTestRequestStringUnixSecondsArrayArrayRequest handles test_request_string_unix-seconds_array_array operation. +// handleTestRequestStringUnixMilliNullableArrayArrayRequest handles test_request_string_unix-milli_nullable_array_array operation. // -// POST /test_request_string_unix-seconds_array_array -func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-milli_nullable_array_array +func (s *Server) handleTestRequestStringUnixMilliNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_array_array"), + otelogen.OperationID("test_request_string_unix-milli_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-milli_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(), "TestRequestStringUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69455,11 +69464,11 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsArrayArray", - ID: "test_request_string_unix-seconds_array_array", + Name: "TestRequestStringUnixMilliNullableArrayArray", + ID: "test_request_string_unix-milli_nullable_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69479,16 +69488,16 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsArrayArray", + OperationName: "TestRequestStringUnixMilliNullableArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-seconds_array_array", + OperationID: "test_request_string_unix-milli_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]time.Time + Request = [][]NilStringUnixMilli Params = struct{} Response = *Error ) @@ -69501,12 +69510,12 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixMilliNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -69514,7 +69523,7 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str return } - if err := encodeTestRequestStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69523,18 +69532,18 @@ func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]str } } -// handleTestRequestStringUnixSecondsNullableRequest handles test_request_string_unix-seconds_nullable operation. +// handleTestRequestStringUnixNanoRequest handles test_request_string_unix-nano operation. // -// POST /test_request_string_unix-seconds_nullable -func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-nano +func (s *Server) handleTestRequestStringUnixNanoRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable"), + otelogen.OperationID("test_request_string_unix-nano"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_unix-nano"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNano", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69559,11 +69568,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsNullable", - ID: "test_request_string_unix-seconds_nullable", + Name: "TestRequestStringUnixNano", + ID: "test_request_string_unix-nano", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsNullableRequest(r) + request, close, err := s.decodeTestRequestStringUnixNanoRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69583,16 +69592,16 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsNullable", + OperationName: "TestRequestStringUnixNano", OperationSummary: "", - OperationID: "test_request_string_unix-seconds_nullable", + OperationID: "test_request_string_unix-nano", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = OptNilStringUnixSeconds + Request = OptStringUnixNano Params = struct{} Response = *Error ) @@ -69605,12 +69614,12 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestStringUnixNano(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsNullable(ctx, request) + response, err = s.h.TestRequestStringUnixNano(ctx, request) } if err != nil { recordError("Internal", err) @@ -69618,7 +69627,7 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin return } - if err := encodeTestRequestStringUnixSecondsNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNanoResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69627,18 +69636,18 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]strin } } -// handleTestRequestStringUnixSecondsNullableArrayRequest handles test_request_string_unix-seconds_nullable_array operation. +// handleTestRequestStringUnixNanoArrayRequest handles test_request_string_unix-nano_array operation. // -// POST /test_request_string_unix-seconds_nullable_array -func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-nano_array +func (s *Server) handleTestRequestStringUnixNanoArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable_array"), + otelogen.OperationID("test_request_string_unix-nano_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-nano_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69663,11 +69672,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsNullableArray", - ID: "test_request_string_unix-seconds_nullable_array", + Name: "TestRequestStringUnixNanoArray", + ID: "test_request_string_unix-nano_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixNanoArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69687,16 +69696,16 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsNullableArray", + OperationName: "TestRequestStringUnixNanoArray", OperationSummary: "", - OperationID: "test_request_string_unix-seconds_nullable_array", + OperationID: "test_request_string_unix-nano_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = []NilStringUnixSeconds + Request = []time.Time Params = struct{} Response = *Error ) @@ -69709,12 +69718,12 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixNanoArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixNanoArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -69722,7 +69731,7 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] return } - if err := encodeTestRequestStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNanoArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69731,18 +69740,18 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0] } } -// handleTestRequestStringUnixSecondsNullableArrayArrayRequest handles test_request_string_unix-seconds_nullable_array_array operation. +// handleTestRequestStringUnixNanoArrayArrayRequest handles test_request_string_unix-nano_array_array operation. // -// POST /test_request_string_unix-seconds_nullable_array_array -func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-nano_array_array +func (s *Server) handleTestRequestStringUnixNanoArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_request_string_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-nano_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-nano_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(), "TestRequestStringUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69767,11 +69776,11 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestRequestStringUnixSecondsNullableArrayArray", - ID: "test_request_string_unix-seconds_nullable_array_array", + Name: "TestRequestStringUnixNanoArrayArray", + ID: "test_request_string_unix-nano_array_array", } ) - request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixNanoArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69791,16 +69800,16 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestRequestStringUnixSecondsNullableArrayArray", + OperationName: "TestRequestStringUnixNanoArrayArray", OperationSummary: "", - OperationID: "test_request_string_unix-seconds_nullable_array_array", + OperationID: "test_request_string_unix-nano_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = [][]NilStringUnixSeconds + Request = [][]time.Time Params = struct{} Response = *Error ) @@ -69813,12 +69822,12 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixNanoArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixNanoArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -69826,7 +69835,7 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg return } - if err := encodeTestRequestStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNanoArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69835,18 +69844,18 @@ func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(arg } } -// handleTestResponseAnyRequest handles test_response_Any operation. +// handleTestRequestStringUnixNanoNullableRequest handles test_request_string_unix-nano_nullable operation. // -// POST /test_response_Any -func (s *Server) handleTestResponseAnyRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-nano_nullable +func (s *Server) handleTestRequestStringUnixNanoNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_Any"), + otelogen.OperationID("test_request_string_unix-nano_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_Any"), + semconv.HTTPRouteKey.String("/test_request_string_unix-nano_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseAny", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69871,11 +69880,11 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, argsEscaped bool, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseAny", - ID: "test_response_Any", + Name: "TestRequestStringUnixNanoNullable", + ID: "test_request_string_unix-nano_nullable", } ) - request, close, err := s.decodeTestResponseAnyRequest(r) + request, close, err := s.decodeTestRequestStringUnixNanoNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69891,22 +69900,22 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, argsEscaped bool, } }() - var response jx.Raw + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseAny", + OperationName: "TestRequestStringUnixNanoNullable", OperationSummary: "", - OperationID: "test_response_Any", + OperationID: "test_request_string_unix-nano_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = OptNilStringUnixNano Params = struct{} - Response = jx.Raw + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -69917,12 +69926,12 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, argsEscaped bool, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseAny(ctx, request) + response, err = s.h.TestRequestStringUnixNanoNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseAny(ctx, request) + response, err = s.h.TestRequestStringUnixNanoNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -69930,7 +69939,7 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, argsEscaped bool, return } - if err := encodeTestResponseAnyResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNanoNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -69939,18 +69948,18 @@ func (s *Server) handleTestResponseAnyRequest(args [0]string, argsEscaped bool, } } -// handleTestResponseBooleanRequest handles test_response_boolean operation. +// handleTestRequestStringUnixNanoNullableArrayRequest handles test_request_string_unix-nano_nullable_array operation. // -// POST /test_response_boolean -func (s *Server) handleTestResponseBooleanRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-nano_nullable_array +func (s *Server) handleTestRequestStringUnixNanoNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean"), + otelogen.OperationID("test_request_string_unix-nano_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_boolean"), + semconv.HTTPRouteKey.String("/test_request_string_unix-nano_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBoolean", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -69975,11 +69984,11 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, argsEscaped bo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBoolean", - ID: "test_response_boolean", + Name: "TestRequestStringUnixNanoNullableArray", + ID: "test_request_string_unix-nano_nullable_array", } ) - request, close, err := s.decodeTestResponseBooleanRequest(r) + request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -69995,22 +70004,22 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, argsEscaped bo } }() - var response bool + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBoolean", + OperationName: "TestRequestStringUnixNanoNullableArray", OperationSummary: "", - OperationID: "test_response_boolean", + OperationID: "test_request_string_unix-nano_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = []NilStringUnixNano Params = struct{} - Response = bool + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70021,12 +70030,12 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, argsEscaped bo mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseBoolean(ctx, request) + response, err = s.h.TestRequestStringUnixNanoNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseBoolean(ctx, request) + response, err = s.h.TestRequestStringUnixNanoNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -70034,7 +70043,7 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, argsEscaped bo return } - if err := encodeTestResponseBooleanResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNanoNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70043,18 +70052,18 @@ func (s *Server) handleTestResponseBooleanRequest(args [0]string, argsEscaped bo } } -// handleTestResponseBooleanArrayRequest handles test_response_boolean_array operation. +// handleTestRequestStringUnixNanoNullableArrayArrayRequest handles test_request_string_unix-nano_nullable_array_array operation. // -// POST /test_response_boolean_array -func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-nano_nullable_array_array +func (s *Server) handleTestRequestStringUnixNanoNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_array"), + otelogen.OperationID("test_request_string_unix-nano_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_boolean_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-nano_nullable_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(), "TestRequestStringUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70079,11 +70088,11 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanArray", - ID: "test_response_boolean_array", + Name: "TestRequestStringUnixNanoNullableArrayArray", + ID: "test_request_string_unix-nano_nullable_array_array", } ) - request, close, err := s.decodeTestResponseBooleanArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70099,22 +70108,22 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, argsEscap } }() - var response []bool + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanArray", + OperationName: "TestRequestStringUnixNanoNullableArrayArray", OperationSummary: "", - OperationID: "test_response_boolean_array", + OperationID: "test_request_string_unix-nano_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = [][]NilStringUnixNano Params = struct{} - Response = []bool + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70125,12 +70134,12 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseBooleanArray(ctx, request) + response, err = s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseBooleanArray(ctx, request) + response, err = s.h.TestRequestStringUnixNanoNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -70138,7 +70147,7 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, argsEscap return } - if err := encodeTestResponseBooleanArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70147,18 +70156,18 @@ func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, argsEscap } } -// handleTestResponseBooleanArrayArrayRequest handles test_response_boolean_array_array operation. +// handleTestRequestStringUnixNullableRequest handles test_request_string_unix_nullable operation. // -// POST /test_response_boolean_array_array -func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix_nullable +func (s *Server) handleTestRequestStringUnixNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_array_array"), + otelogen.OperationID("test_request_string_unix_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_boolean_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70183,11 +70192,11 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanArrayArray", - ID: "test_response_boolean_array_array", + Name: "TestRequestStringUnixNullable", + ID: "test_request_string_unix_nullable", } ) - request, close, err := s.decodeTestResponseBooleanArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70203,22 +70212,22 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, args } }() - var response [][]bool + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanArrayArray", + OperationName: "TestRequestStringUnixNullable", OperationSummary: "", - OperationID: "test_response_boolean_array_array", + OperationID: "test_request_string_unix_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = OptNilStringUnixSeconds Params = struct{} - Response = [][]bool + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70229,12 +70238,12 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseBooleanArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseBooleanArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -70242,7 +70251,7 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, args return } - if err := encodeTestResponseBooleanArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70251,18 +70260,18 @@ func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, args } } -// handleTestResponseBooleanNullableRequest handles test_response_boolean_nullable operation. +// handleTestRequestStringUnixNullableArrayRequest handles test_request_string_unix_nullable_array operation. // -// POST /test_response_boolean_nullable -func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix_nullable_array +func (s *Server) handleTestRequestStringUnixNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable"), + otelogen.OperationID("test_request_string_unix_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_boolean_nullable"), + semconv.HTTPRouteKey.String("/test_request_string_unix_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(), "TestRequestStringUnixNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70287,11 +70296,11 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanNullable", - ID: "test_response_boolean_nullable", + Name: "TestRequestStringUnixNullableArray", + ID: "test_request_string_unix_nullable_array", } ) - request, close, err := s.decodeTestResponseBooleanNullableRequest(r) + request, close, err := s.decodeTestRequestStringUnixNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70307,22 +70316,22 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, argsEs } }() - var response NilBool + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanNullable", + OperationName: "TestRequestStringUnixNullableArray", OperationSummary: "", - OperationID: "test_response_boolean_nullable", + OperationID: "test_request_string_unix_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = []NilStringUnixSeconds Params = struct{} - Response = NilBool + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70333,12 +70342,12 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseBooleanNullable(ctx, request) + response, err = s.h.TestRequestStringUnixNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseBooleanNullable(ctx, request) + response, err = s.h.TestRequestStringUnixNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -70346,7 +70355,7 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, argsEs return } - if err := encodeTestResponseBooleanNullableResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70355,18 +70364,18 @@ func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, argsEs } } -// handleTestResponseBooleanNullableArrayRequest handles test_response_boolean_nullable_array operation. +// handleTestRequestStringUnixNullableArrayArrayRequest handles test_request_string_unix_nullable_array_array operation. // -// POST /test_response_boolean_nullable_array -func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix_nullable_array_array +func (s *Server) handleTestRequestStringUnixNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable_array"), + otelogen.OperationID("test_request_string_unix_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_boolean_nullable_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix_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(), "TestRequestStringUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70391,11 +70400,11 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanNullableArray", - ID: "test_response_boolean_nullable_array", + Name: "TestRequestStringUnixNullableArrayArray", + ID: "test_request_string_unix_nullable_array_array", } ) - request, close, err := s.decodeTestResponseBooleanNullableArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70411,22 +70420,22 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, a } }() - var response []NilBool + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanNullableArray", + OperationName: "TestRequestStringUnixNullableArrayArray", OperationSummary: "", - OperationID: "test_response_boolean_nullable_array", + OperationID: "test_request_string_unix_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = [][]NilStringUnixSeconds Params = struct{} - Response = []NilBool + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70437,12 +70446,12 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseBooleanNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseBooleanNullableArray(ctx, request) + response, err = s.h.TestRequestStringUnixNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -70450,7 +70459,7 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, a return } - if err := encodeTestResponseBooleanNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70459,18 +70468,18 @@ func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, a } } -// handleTestResponseBooleanNullableArrayArrayRequest handles test_response_boolean_nullable_array_array operation. +// handleTestRequestStringUnixSecondsRequest handles test_request_string_unix-seconds operation. // -// POST /test_response_boolean_nullable_array_array -func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-seconds +func (s *Server) handleTestRequestStringUnixSecondsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_boolean_nullable_array_array"), + otelogen.OperationID("test_request_string_unix-seconds"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_boolean_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-seconds"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSeconds", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70495,11 +70504,11 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseBooleanNullableArrayArray", - ID: "test_response_boolean_nullable_array_array", + Name: "TestRequestStringUnixSeconds", + ID: "test_request_string_unix-seconds", } ) - request, close, err := s.decodeTestResponseBooleanNullableArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixSecondsRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70515,22 +70524,22 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri } }() - var response [][]NilBool + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseBooleanNullableArrayArray", + OperationName: "TestRequestStringUnixSeconds", OperationSummary: "", - OperationID: "test_response_boolean_nullable_array_array", + OperationID: "test_request_string_unix-seconds", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = OptStringUnixSeconds Params = struct{} - Response = [][]NilBool + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70541,12 +70550,12 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseBooleanNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixSeconds(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseBooleanNullableArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixSeconds(ctx, request) } if err != nil { recordError("Internal", err) @@ -70554,7 +70563,7 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri return } - if err := encodeTestResponseBooleanNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixSecondsResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70563,18 +70572,18 @@ func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]stri } } -// handleTestResponseEmptyStructRequest handles test_response_EmptyStruct operation. +// handleTestRequestStringUnixSecondsArrayRequest handles test_request_string_unix-seconds_array operation. // -// POST /test_response_EmptyStruct -func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-seconds_array +func (s *Server) handleTestRequestStringUnixSecondsArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_EmptyStruct"), + otelogen.OperationID("test_request_string_unix-seconds_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_EmptyStruct"), + semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseEmptyStruct", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70599,11 +70608,11 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseEmptyStruct", - ID: "test_response_EmptyStruct", + Name: "TestRequestStringUnixSecondsArray", + ID: "test_request_string_unix-seconds_array", } ) - request, close, err := s.decodeTestResponseEmptyStructRequest(r) + request, close, err := s.decodeTestRequestStringUnixSecondsArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70619,22 +70628,22 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, argsEscape } }() - var response *TestResponseEmptyStructOK + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseEmptyStruct", + OperationName: "TestRequestStringUnixSecondsArray", OperationSummary: "", - OperationID: "test_response_EmptyStruct", + OperationID: "test_request_string_unix-seconds_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = []time.Time Params = struct{} - Response = *TestResponseEmptyStructOK + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70645,12 +70654,12 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - err = s.h.TestResponseEmptyStruct(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsArray(ctx, request) return response, err }, ) } else { - err = s.h.TestResponseEmptyStruct(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -70658,7 +70667,7 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, argsEscape return } - if err := encodeTestResponseEmptyStructResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixSecondsArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70667,18 +70676,18 @@ func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, argsEscape } } -// handleTestResponseFormatTestRequest handles test_response_FormatTest operation. +// handleTestRequestStringUnixSecondsArrayArrayRequest handles test_request_string_unix-seconds_array_array operation. // -// POST /test_response_FormatTest -func (s *Server) handleTestResponseFormatTestRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-seconds_array_array +func (s *Server) handleTestRequestStringUnixSecondsArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_FormatTest"), + otelogen.OperationID("test_request_string_unix-seconds_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_FormatTest"), + semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_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(), "TestRequestStringUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70703,11 +70712,11 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseFormatTest", - ID: "test_response_FormatTest", + Name: "TestRequestStringUnixSecondsArrayArray", + ID: "test_request_string_unix-seconds_array_array", } ) - request, close, err := s.decodeTestResponseFormatTestRequest(r) + request, close, err := s.decodeTestRequestStringUnixSecondsArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70723,22 +70732,22 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, argsEscaped } }() - var response *TestResponseFormatTestOK + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseFormatTest", + OperationName: "TestRequestStringUnixSecondsArrayArray", OperationSummary: "", - OperationID: "test_response_FormatTest", + OperationID: "test_request_string_unix-seconds_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = [][]time.Time Params = struct{} - Response = *TestResponseFormatTestOK + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70749,12 +70758,12 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseFormatTest(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseFormatTest(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -70762,7 +70771,7 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, argsEscaped return } - if err := encodeTestResponseFormatTestResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixSecondsArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70771,18 +70780,18 @@ func (s *Server) handleTestResponseFormatTestRequest(args [0]string, argsEscaped } } -// handleTestResponseIntegerRequest handles test_response_integer operation. +// handleTestRequestStringUnixSecondsNullableRequest handles test_request_string_unix-seconds_nullable operation. // -// POST /test_response_integer -func (s *Server) handleTestResponseIntegerRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-seconds_nullable +func (s *Server) handleTestRequestStringUnixSecondsNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer"), + otelogen.OperationID("test_request_string_unix-seconds_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer"), + semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseInteger", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70807,11 +70816,11 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, argsEscaped bo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseInteger", - ID: "test_response_integer", + Name: "TestRequestStringUnixSecondsNullable", + ID: "test_request_string_unix-seconds_nullable", } ) - request, close, err := s.decodeTestResponseIntegerRequest(r) + request, close, err := s.decodeTestRequestStringUnixSecondsNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70827,22 +70836,22 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, argsEscaped bo } }() - var response int + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseInteger", + OperationName: "TestRequestStringUnixSecondsNullable", OperationSummary: "", - OperationID: "test_response_integer", + OperationID: "test_request_string_unix-seconds_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = OptNilStringUnixSeconds Params = struct{} - Response = int + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70853,12 +70862,12 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, argsEscaped bo mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseInteger(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseInteger(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -70866,7 +70875,7 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, argsEscaped bo return } - if err := encodeTestResponseIntegerResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixSecondsNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70875,18 +70884,18 @@ func (s *Server) handleTestResponseIntegerRequest(args [0]string, argsEscaped bo } } -// handleTestResponseIntegerArrayRequest handles test_response_integer_array operation. +// handleTestRequestStringUnixSecondsNullableArrayRequest handles test_request_string_unix-seconds_nullable_array operation. // -// POST /test_response_integer_array -func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-seconds_nullable_array +func (s *Server) handleTestRequestStringUnixSecondsNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_array"), + otelogen.OperationID("test_request_string_unix-seconds_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -70911,11 +70920,11 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerArray", - ID: "test_response_integer_array", + Name: "TestRequestStringUnixSecondsNullableArray", + ID: "test_request_string_unix-seconds_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -70931,22 +70940,22 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, argsEscap } }() - var response []int + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerArray", + OperationName: "TestRequestStringUnixSecondsNullableArray", OperationSummary: "", - OperationID: "test_response_integer_array", + OperationID: "test_request_string_unix-seconds_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = []NilStringUnixSeconds Params = struct{} - Response = []int + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -70957,12 +70966,12 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerArray(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerArray(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -70970,7 +70979,7 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, argsEscap return } - if err := encodeTestResponseIntegerArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixSecondsNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -70979,18 +70988,18 @@ func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, argsEscap } } -// handleTestResponseIntegerArrayArrayRequest handles test_response_integer_array_array operation. +// handleTestRequestStringUnixSecondsNullableArrayArrayRequest handles test_request_string_unix-seconds_nullable_array_array operation. // -// POST /test_response_integer_array_array -func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_request_string_unix-seconds_nullable_array_array +func (s *Server) handleTestRequestStringUnixSecondsNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_array_array"), + otelogen.OperationID("test_request_string_unix-seconds_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_array_array"), + semconv.HTTPRouteKey.String("/test_request_string_unix-seconds_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestRequestStringUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71015,11 +71024,11 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerArrayArray", - ID: "test_response_integer_array_array", + Name: "TestRequestStringUnixSecondsNullableArrayArray", + ID: "test_request_string_unix-seconds_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerArrayArrayRequest(r) + request, close, err := s.decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71035,22 +71044,22 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, args } }() - var response [][]int + var response *Error if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerArrayArray", + OperationName: "TestRequestStringUnixSecondsNullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_array_array", + OperationID: "test_request_string_unix-seconds_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, } type ( - Request = string + Request = [][]NilStringUnixSeconds Params = struct{} - Response = [][]int + Response = *Error ) response, err = middleware.HookMiddleware[ Request, @@ -71061,12 +71070,12 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerArrayArray(ctx, request) + response, err = s.h.TestRequestStringUnixSecondsNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -71074,7 +71083,7 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, args return } - if err := encodeTestResponseIntegerArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestRequestStringUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71083,18 +71092,18 @@ func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, args } } -// handleTestResponseIntegerInt16Request handles test_response_integer_int16 operation. +// handleTestResponseAnyRequest handles test_response_Any operation. // -// POST /test_response_integer_int16 -func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_Any +func (s *Server) handleTestResponseAnyRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int16"), + otelogen.OperationID("test_response_Any"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int16"), + semconv.HTTPRouteKey.String("/test_response_Any"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseAny", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71119,11 +71128,11 @@ func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt16", - ID: "test_response_integer_int16", + Name: "TestResponseAny", + ID: "test_response_Any", } ) - request, close, err := s.decodeTestResponseIntegerInt16Request(r) + request, close, err := s.decodeTestResponseAnyRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71139,13 +71148,13 @@ func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscap } }() - var response int16 + var response jx.Raw if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt16", + OperationName: "TestResponseAny", OperationSummary: "", - OperationID: "test_response_integer_int16", + OperationID: "test_response_Any", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71154,7 +71163,7 @@ func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = int16 + Response = jx.Raw ) response, err = middleware.HookMiddleware[ Request, @@ -71165,12 +71174,12 @@ func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt16(ctx, request) + response, err = s.h.TestResponseAny(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt16(ctx, request) + response, err = s.h.TestResponseAny(ctx, request) } if err != nil { recordError("Internal", err) @@ -71178,7 +71187,7 @@ func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscap return } - if err := encodeTestResponseIntegerInt16Response(response, w, span); err != nil { + if err := encodeTestResponseAnyResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71187,18 +71196,18 @@ func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscap } } -// handleTestResponseIntegerInt16ArrayRequest handles test_response_integer_int16_array operation. +// handleTestResponseBooleanRequest handles test_response_boolean operation. // -// POST /test_response_integer_int16_array -func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_boolean +func (s *Server) handleTestResponseBooleanRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int16_array"), + otelogen.OperationID("test_response_boolean"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int16_array"), + semconv.HTTPRouteKey.String("/test_response_boolean"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBoolean", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71223,11 +71232,11 @@ func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt16Array", - ID: "test_response_integer_int16_array", + Name: "TestResponseBoolean", + ID: "test_response_boolean", } ) - request, close, err := s.decodeTestResponseIntegerInt16ArrayRequest(r) + request, close, err := s.decodeTestResponseBooleanRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71243,13 +71252,13 @@ func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, args } }() - var response []int16 + var response bool if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt16Array", + OperationName: "TestResponseBoolean", OperationSummary: "", - OperationID: "test_response_integer_int16_array", + OperationID: "test_response_boolean", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71258,7 +71267,7 @@ func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = []int16 + Response = bool ) response, err = middleware.HookMiddleware[ Request, @@ -71269,12 +71278,12 @@ func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt16Array(ctx, request) + response, err = s.h.TestResponseBoolean(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt16Array(ctx, request) + response, err = s.h.TestResponseBoolean(ctx, request) } if err != nil { recordError("Internal", err) @@ -71282,7 +71291,7 @@ func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, args return } - if err := encodeTestResponseIntegerInt16ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseBooleanResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71291,18 +71300,18 @@ func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, args } } -// handleTestResponseIntegerInt16ArrayArrayRequest handles test_response_integer_int16_array_array operation. +// handleTestResponseBooleanArrayRequest handles test_response_boolean_array operation. // -// POST /test_response_integer_int16_array_array -func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_boolean_array +func (s *Server) handleTestResponseBooleanArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int16_array_array"), + otelogen.OperationID("test_response_boolean_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int16_array_array"), + semconv.HTTPRouteKey.String("/test_response_boolean_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71327,11 +71336,11 @@ func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt16ArrayArray", - ID: "test_response_integer_int16_array_array", + Name: "TestResponseBooleanArray", + ID: "test_response_boolean_array", } ) - request, close, err := s.decodeTestResponseIntegerInt16ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseBooleanArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71347,13 +71356,13 @@ func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, } }() - var response [][]int16 + var response []bool if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt16ArrayArray", + OperationName: "TestResponseBooleanArray", OperationSummary: "", - OperationID: "test_response_integer_int16_array_array", + OperationID: "test_response_boolean_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71362,7 +71371,7 @@ func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int16 + Response = []bool ) response, err = middleware.HookMiddleware[ Request, @@ -71373,12 +71382,12 @@ func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt16ArrayArray(ctx, request) + response, err = s.h.TestResponseBooleanArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt16ArrayArray(ctx, request) + response, err = s.h.TestResponseBooleanArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -71386,7 +71395,7 @@ func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerInt16ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseBooleanArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71395,18 +71404,18 @@ func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, } } -// handleTestResponseIntegerInt16NullableRequest handles test_response_integer_int16_nullable operation. +// handleTestResponseBooleanArrayArrayRequest handles test_response_boolean_array_array operation. // -// POST /test_response_integer_int16_nullable -func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_boolean_array_array +func (s *Server) handleTestResponseBooleanArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int16_nullable"), + otelogen.OperationID("test_response_boolean_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int16_nullable"), + semconv.HTTPRouteKey.String("/test_response_boolean_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71431,11 +71440,11 @@ func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt16Nullable", - ID: "test_response_integer_int16_nullable", + Name: "TestResponseBooleanArrayArray", + ID: "test_response_boolean_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt16NullableRequest(r) + request, close, err := s.decodeTestResponseBooleanArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71451,13 +71460,13 @@ func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, a } }() - var response NilInt16 + var response [][]bool if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt16Nullable", + OperationName: "TestResponseBooleanArrayArray", OperationSummary: "", - OperationID: "test_response_integer_int16_nullable", + OperationID: "test_response_boolean_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71466,7 +71475,7 @@ func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, a type ( Request = string Params = struct{} - Response = NilInt16 + Response = [][]bool ) response, err = middleware.HookMiddleware[ Request, @@ -71477,12 +71486,12 @@ func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt16Nullable(ctx, request) + response, err = s.h.TestResponseBooleanArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt16Nullable(ctx, request) + response, err = s.h.TestResponseBooleanArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -71490,7 +71499,7 @@ func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, a return } - if err := encodeTestResponseIntegerInt16NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseBooleanArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71499,18 +71508,18 @@ func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, a } } -// handleTestResponseIntegerInt16NullableArrayRequest handles test_response_integer_int16_nullable_array operation. +// handleTestResponseBooleanNullableRequest handles test_response_boolean_nullable operation. // -// POST /test_response_integer_int16_nullable_array -func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_boolean_nullable +func (s *Server) handleTestResponseBooleanNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int16_nullable_array"), + otelogen.OperationID("test_response_boolean_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int16_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_boolean_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71535,11 +71544,11 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt16NullableArray", - ID: "test_response_integer_int16_nullable_array", + Name: "TestResponseBooleanNullable", + ID: "test_response_boolean_nullable", } ) - request, close, err := s.decodeTestResponseIntegerInt16NullableArrayRequest(r) + request, close, err := s.decodeTestResponseBooleanNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71555,13 +71564,13 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]stri } }() - var response []NilInt16 + var response NilBool if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt16NullableArray", + OperationName: "TestResponseBooleanNullable", OperationSummary: "", - OperationID: "test_response_integer_int16_nullable_array", + OperationID: "test_response_boolean_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71570,7 +71579,7 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilInt16 + Response = NilBool ) response, err = middleware.HookMiddleware[ Request, @@ -71581,12 +71590,12 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt16NullableArray(ctx, request) + response, err = s.h.TestResponseBooleanNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt16NullableArray(ctx, request) + response, err = s.h.TestResponseBooleanNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -71594,7 +71603,7 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerInt16NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseBooleanNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71603,18 +71612,18 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]stri } } -// handleTestResponseIntegerInt16NullableArrayArrayRequest handles test_response_integer_int16_nullable_array_array operation. +// handleTestResponseBooleanNullableArrayRequest handles test_response_boolean_nullable_array operation. // -// POST /test_response_integer_int16_nullable_array_array -func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_boolean_nullable_array +func (s *Server) handleTestResponseBooleanNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int16_nullable_array_array"), + otelogen.OperationID("test_response_boolean_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int16_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_boolean_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseBooleanNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71639,11 +71648,11 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt16NullableArrayArray", - ID: "test_response_integer_int16_nullable_array_array", + Name: "TestResponseBooleanNullableArray", + ID: "test_response_boolean_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerInt16NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseBooleanNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71659,13 +71668,13 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0 } }() - var response [][]NilInt16 + var response []NilBool if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt16NullableArrayArray", + OperationName: "TestResponseBooleanNullableArray", OperationSummary: "", - OperationID: "test_response_integer_int16_nullable_array_array", + OperationID: "test_response_boolean_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71674,7 +71683,7 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilInt16 + Response = []NilBool ) response, err = middleware.HookMiddleware[ Request, @@ -71685,12 +71694,12 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt16NullableArrayArray(ctx, request) + response, err = s.h.TestResponseBooleanNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt16NullableArrayArray(ctx, request) + response, err = s.h.TestResponseBooleanNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -71698,7 +71707,7 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseIntegerInt16NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseBooleanNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71707,18 +71716,18 @@ func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0 } } -// handleTestResponseIntegerInt32Request handles test_response_integer_int32 operation. +// handleTestResponseBooleanNullableArrayArrayRequest handles test_response_boolean_nullable_array_array operation. // -// POST /test_response_integer_int32 -func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_boolean_nullable_array_array +func (s *Server) handleTestResponseBooleanNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32"), + otelogen.OperationID("test_response_boolean_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int32"), + semconv.HTTPRouteKey.String("/test_response_boolean_nullable_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(), "TestResponseBooleanNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71743,11 +71752,11 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32", - ID: "test_response_integer_int32", + Name: "TestResponseBooleanNullableArrayArray", + ID: "test_response_boolean_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt32Request(r) + request, close, err := s.decodeTestResponseBooleanNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71763,13 +71772,13 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscap } }() - var response int32 + var response [][]NilBool if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32", + OperationName: "TestResponseBooleanNullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_int32", + OperationID: "test_response_boolean_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71778,7 +71787,7 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = int32 + Response = [][]NilBool ) response, err = middleware.HookMiddleware[ Request, @@ -71789,12 +71798,12 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt32(ctx, request) + response, err = s.h.TestResponseBooleanNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt32(ctx, request) + response, err = s.h.TestResponseBooleanNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -71802,7 +71811,7 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscap return } - if err := encodeTestResponseIntegerInt32Response(response, w, span); err != nil { + if err := encodeTestResponseBooleanNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71811,18 +71820,18 @@ func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscap } } -// handleTestResponseIntegerInt32ArrayRequest handles test_response_integer_int32_array operation. +// handleTestResponseEmptyStructRequest handles test_response_EmptyStruct operation. // -// POST /test_response_integer_int32_array -func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_EmptyStruct +func (s *Server) handleTestResponseEmptyStructRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_array"), + otelogen.OperationID("test_response_EmptyStruct"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int32_array"), + semconv.HTTPRouteKey.String("/test_response_EmptyStruct"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseEmptyStruct", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71847,11 +71856,11 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32Array", - ID: "test_response_integer_int32_array", + Name: "TestResponseEmptyStruct", + ID: "test_response_EmptyStruct", } ) - request, close, err := s.decodeTestResponseIntegerInt32ArrayRequest(r) + request, close, err := s.decodeTestResponseEmptyStructRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71867,13 +71876,13 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, args } }() - var response []int32 + var response *TestResponseEmptyStructOK if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32Array", + OperationName: "TestResponseEmptyStruct", OperationSummary: "", - OperationID: "test_response_integer_int32_array", + OperationID: "test_response_EmptyStruct", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71882,7 +71891,7 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = []int32 + Response = *TestResponseEmptyStructOK ) response, err = middleware.HookMiddleware[ Request, @@ -71893,12 +71902,12 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt32Array(ctx, request) + err = s.h.TestResponseEmptyStruct(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt32Array(ctx, request) + err = s.h.TestResponseEmptyStruct(ctx, request) } if err != nil { recordError("Internal", err) @@ -71906,7 +71915,7 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, args return } - if err := encodeTestResponseIntegerInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseEmptyStructResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -71915,18 +71924,18 @@ func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, args } } -// handleTestResponseIntegerInt32ArrayArrayRequest handles test_response_integer_int32_array_array operation. +// handleTestResponseFormatTestRequest handles test_response_FormatTest operation. // -// POST /test_response_integer_int32_array_array -func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_FormatTest +func (s *Server) handleTestResponseFormatTestRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_array_array"), + otelogen.OperationID("test_response_FormatTest"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int32_array_array"), + semconv.HTTPRouteKey.String("/test_response_FormatTest"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseFormatTest", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -71951,11 +71960,11 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32ArrayArray", - ID: "test_response_integer_int32_array_array", + Name: "TestResponseFormatTest", + ID: "test_response_FormatTest", } ) - request, close, err := s.decodeTestResponseIntegerInt32ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseFormatTestRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -71971,13 +71980,13 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, } }() - var response [][]int32 + var response *TestResponseFormatTestOK if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32ArrayArray", + OperationName: "TestResponseFormatTest", OperationSummary: "", - OperationID: "test_response_integer_int32_array_array", + OperationID: "test_response_FormatTest", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -71986,7 +71995,7 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int32 + Response = *TestResponseFormatTestOK ) response, err = middleware.HookMiddleware[ Request, @@ -71997,12 +72006,12 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt32ArrayArray(ctx, request) + response, err = s.h.TestResponseFormatTest(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt32ArrayArray(ctx, request) + response, err = s.h.TestResponseFormatTest(ctx, request) } if err != nil { recordError("Internal", err) @@ -72010,7 +72019,7 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseFormatTestResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72019,18 +72028,18 @@ func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, } } -// handleTestResponseIntegerInt32NullableRequest handles test_response_integer_int32_nullable operation. +// handleTestResponseIntegerRequest handles test_response_integer operation. // -// POST /test_response_integer_int32_nullable -func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer +func (s *Server) handleTestResponseIntegerRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable"), + otelogen.OperationID("test_response_integer"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int32_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseInteger", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72055,11 +72064,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32Nullable", - ID: "test_response_integer_int32_nullable", + Name: "TestResponseInteger", + ID: "test_response_integer", } ) - request, close, err := s.decodeTestResponseIntegerInt32NullableRequest(r) + request, close, err := s.decodeTestResponseIntegerRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72075,13 +72084,13 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, a } }() - var response NilInt32 + var response int if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32Nullable", + OperationName: "TestResponseInteger", OperationSummary: "", - OperationID: "test_response_integer_int32_nullable", + OperationID: "test_response_integer", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72090,7 +72099,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, a type ( Request = string Params = struct{} - Response = NilInt32 + Response = int ) response, err = middleware.HookMiddleware[ Request, @@ -72101,12 +72110,12 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt32Nullable(ctx, request) + response, err = s.h.TestResponseInteger(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt32Nullable(ctx, request) + response, err = s.h.TestResponseInteger(ctx, request) } if err != nil { recordError("Internal", err) @@ -72114,7 +72123,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, a return } - if err := encodeTestResponseIntegerInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72123,18 +72132,18 @@ func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, a } } -// handleTestResponseIntegerInt32NullableArrayRequest handles test_response_integer_int32_nullable_array operation. +// handleTestResponseIntegerArrayRequest handles test_response_integer_array operation. // -// POST /test_response_integer_int32_nullable_array -func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_array +func (s *Server) handleTestResponseIntegerArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable_array"), + otelogen.OperationID("test_response_integer_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int32_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72159,11 +72168,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32NullableArray", - ID: "test_response_integer_int32_nullable_array", + Name: "TestResponseIntegerArray", + ID: "test_response_integer_array", } ) - request, close, err := s.decodeTestResponseIntegerInt32NullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72179,13 +72188,13 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri } }() - var response []NilInt32 + var response []int if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32NullableArray", + OperationName: "TestResponseIntegerArray", OperationSummary: "", - OperationID: "test_response_integer_int32_nullable_array", + OperationID: "test_response_integer_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72194,7 +72203,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilInt32 + Response = []int ) response, err = middleware.HookMiddleware[ Request, @@ -72205,12 +72214,12 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt32NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt32NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -72218,7 +72227,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72227,18 +72236,18 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]stri } } -// handleTestResponseIntegerInt32NullableArrayArrayRequest handles test_response_integer_int32_nullable_array_array operation. +// handleTestResponseIntegerArrayArrayRequest handles test_response_integer_array_array operation. // -// POST /test_response_integer_int32_nullable_array_array -func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_array_array +func (s *Server) handleTestResponseIntegerArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int32_nullable_array_array"), + otelogen.OperationID("test_response_integer_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72263,11 +72272,11 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt32NullableArrayArray", - ID: "test_response_integer_int32_nullable_array_array", + Name: "TestResponseIntegerArrayArray", + ID: "test_response_integer_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72283,13 +72292,13 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 } }() - var response [][]NilInt32 + var response [][]int if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt32NullableArrayArray", + OperationName: "TestResponseIntegerArrayArray", OperationSummary: "", - OperationID: "test_response_integer_int32_nullable_array_array", + OperationID: "test_response_integer_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72298,7 +72307,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilInt32 + Response = [][]int ) response, err = middleware.HookMiddleware[ Request, @@ -72309,12 +72318,12 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -72322,7 +72331,7 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseIntegerInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72331,18 +72340,18 @@ func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0 } } -// handleTestResponseIntegerInt64Request handles test_response_integer_int64 operation. +// handleTestResponseIntegerInt16Request handles test_response_integer_int16 operation. // -// POST /test_response_integer_int64 -func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int16 +func (s *Server) handleTestResponseIntegerInt16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64"), + otelogen.OperationID("test_response_integer_int16"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int64"), + semconv.HTTPRouteKey.String("/test_response_integer_int16"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72367,11 +72376,11 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64", - ID: "test_response_integer_int64", + Name: "TestResponseIntegerInt16", + ID: "test_response_integer_int16", } ) - request, close, err := s.decodeTestResponseIntegerInt64Request(r) + request, close, err := s.decodeTestResponseIntegerInt16Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72387,13 +72396,13 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscap } }() - var response int64 + var response int16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64", + OperationName: "TestResponseIntegerInt16", OperationSummary: "", - OperationID: "test_response_integer_int64", + OperationID: "test_response_integer_int16", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72402,7 +72411,7 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = int64 + Response = int16 ) response, err = middleware.HookMiddleware[ Request, @@ -72413,12 +72422,12 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt64(ctx, request) + response, err = s.h.TestResponseIntegerInt16(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt64(ctx, request) + response, err = s.h.TestResponseIntegerInt16(ctx, request) } if err != nil { recordError("Internal", err) @@ -72426,7 +72435,7 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscap return } - if err := encodeTestResponseIntegerInt64Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt16Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72435,18 +72444,18 @@ func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscap } } -// handleTestResponseIntegerInt64ArrayRequest handles test_response_integer_int64_array operation. +// handleTestResponseIntegerInt16ArrayRequest handles test_response_integer_int16_array operation. // -// POST /test_response_integer_int64_array -func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int16_array +func (s *Server) handleTestResponseIntegerInt16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_array"), + otelogen.OperationID("test_response_integer_int16_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int64_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int16_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72471,11 +72480,11 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64Array", - ID: "test_response_integer_int64_array", + Name: "TestResponseIntegerInt16Array", + ID: "test_response_integer_int16_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64ArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt16ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72491,13 +72500,13 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, args } }() - var response []int64 + var response []int16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64Array", + OperationName: "TestResponseIntegerInt16Array", OperationSummary: "", - OperationID: "test_response_integer_int64_array", + OperationID: "test_response_integer_int16_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72506,7 +72515,7 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = []int64 + Response = []int16 ) response, err = middleware.HookMiddleware[ Request, @@ -72517,12 +72526,12 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt64Array(ctx, request) + response, err = s.h.TestResponseIntegerInt16Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt64Array(ctx, request) + response, err = s.h.TestResponseIntegerInt16Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -72530,7 +72539,7 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, args return } - if err := encodeTestResponseIntegerInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt16ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72539,18 +72548,18 @@ func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, args } } -// handleTestResponseIntegerInt64ArrayArrayRequest handles test_response_integer_int64_array_array operation. +// handleTestResponseIntegerInt16ArrayArrayRequest handles test_response_integer_int16_array_array operation. // -// POST /test_response_integer_int64_array_array -func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int16_array_array +func (s *Server) handleTestResponseIntegerInt16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_array_array"), + otelogen.OperationID("test_response_integer_int16_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int64_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int16_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72575,11 +72584,11 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64ArrayArray", - ID: "test_response_integer_int64_array_array", + Name: "TestResponseIntegerInt16ArrayArray", + ID: "test_response_integer_int16_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt16ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72595,13 +72604,13 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, } }() - var response [][]int64 + var response [][]int16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64ArrayArray", + OperationName: "TestResponseIntegerInt16ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_int64_array_array", + OperationID: "test_response_integer_int16_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72610,7 +72619,7 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int64 + Response = [][]int16 ) response, err = middleware.HookMiddleware[ Request, @@ -72621,12 +72630,12 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt64ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt16ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt64ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt16ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -72634,7 +72643,7 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt16ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72643,18 +72652,18 @@ func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, } } -// handleTestResponseIntegerInt64NullableRequest handles test_response_integer_int64_nullable operation. +// handleTestResponseIntegerInt16NullableRequest handles test_response_integer_int16_nullable operation. // -// POST /test_response_integer_int64_nullable -func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int16_nullable +func (s *Server) handleTestResponseIntegerInt16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable"), + otelogen.OperationID("test_response_integer_int16_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int64_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_int16_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72679,11 +72688,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64Nullable", - ID: "test_response_integer_int64_nullable", + Name: "TestResponseIntegerInt16Nullable", + ID: "test_response_integer_int16_nullable", } ) - request, close, err := s.decodeTestResponseIntegerInt64NullableRequest(r) + request, close, err := s.decodeTestResponseIntegerInt16NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72699,13 +72708,13 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, a } }() - var response NilInt64 + var response NilInt16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64Nullable", + OperationName: "TestResponseIntegerInt16Nullable", OperationSummary: "", - OperationID: "test_response_integer_int64_nullable", + OperationID: "test_response_integer_int16_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72714,7 +72723,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, a type ( Request = string Params = struct{} - Response = NilInt64 + Response = NilInt16 ) response, err = middleware.HookMiddleware[ Request, @@ -72725,12 +72734,12 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt64Nullable(ctx, request) + response, err = s.h.TestResponseIntegerInt16Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt64Nullable(ctx, request) + response, err = s.h.TestResponseIntegerInt16Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -72738,7 +72747,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, a return } - if err := encodeTestResponseIntegerInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt16NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72747,18 +72756,18 @@ func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, a } } -// handleTestResponseIntegerInt64NullableArrayRequest handles test_response_integer_int64_nullable_array operation. +// handleTestResponseIntegerInt16NullableArrayRequest handles test_response_integer_int16_nullable_array operation. // -// POST /test_response_integer_int64_nullable_array -func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int16_nullable_array +func (s *Server) handleTestResponseIntegerInt16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable_array"), + otelogen.OperationID("test_response_integer_int16_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int64_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int16_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt16NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72783,11 +72792,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64NullableArray", - ID: "test_response_integer_int64_nullable_array", + Name: "TestResponseIntegerInt16NullableArray", + ID: "test_response_integer_int16_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64NullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt16NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72803,13 +72812,13 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri } }() - var response []NilInt64 + var response []NilInt16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64NullableArray", + OperationName: "TestResponseIntegerInt16NullableArray", OperationSummary: "", - OperationID: "test_response_integer_int64_nullable_array", + OperationID: "test_response_integer_int16_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72818,7 +72827,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilInt64 + Response = []NilInt16 ) response, err = middleware.HookMiddleware[ Request, @@ -72829,12 +72838,12 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt64NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt16NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt64NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt16NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -72842,7 +72851,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt16NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72851,18 +72860,18 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]stri } } -// handleTestResponseIntegerInt64NullableArrayArrayRequest handles test_response_integer_int64_nullable_array_array operation. +// handleTestResponseIntegerInt16NullableArrayArrayRequest handles test_response_integer_int16_nullable_array_array operation. // -// POST /test_response_integer_int64_nullable_array_array -func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int16_nullable_array_array +func (s *Server) handleTestResponseIntegerInt16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int64_nullable_array_array"), + otelogen.OperationID("test_response_integer_int16_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int16_nullable_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(), "TestResponseIntegerInt16NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72887,11 +72896,11 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt64NullableArrayArray", - ID: "test_response_integer_int64_nullable_array_array", + Name: "TestResponseIntegerInt16NullableArrayArray", + ID: "test_response_integer_int16_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt16NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -72907,13 +72916,13 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 } }() - var response [][]NilInt64 + var response [][]NilInt16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt64NullableArrayArray", + OperationName: "TestResponseIntegerInt16NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_int64_nullable_array_array", + OperationID: "test_response_integer_int16_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -72922,7 +72931,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilInt64 + Response = [][]NilInt16 ) response, err = middleware.HookMiddleware[ Request, @@ -72933,12 +72942,12 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt16NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt16NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -72946,7 +72955,7 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseIntegerInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt16NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -72955,18 +72964,18 @@ func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0 } } -// handleTestResponseIntegerInt8Request handles test_response_integer_int8 operation. +// handleTestResponseIntegerInt32Request handles test_response_integer_int32 operation. // -// POST /test_response_integer_int8 -func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int32 +func (s *Server) handleTestResponseIntegerInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int8"), + otelogen.OperationID("test_response_integer_int32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int8"), + semconv.HTTPRouteKey.String("/test_response_integer_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -72991,11 +73000,11 @@ func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt8", - ID: "test_response_integer_int8", + Name: "TestResponseIntegerInt32", + ID: "test_response_integer_int32", } ) - request, close, err := s.decodeTestResponseIntegerInt8Request(r) + request, close, err := s.decodeTestResponseIntegerInt32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73011,13 +73020,13 @@ func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscape } }() - var response int8 + var response int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt8", + OperationName: "TestResponseIntegerInt32", OperationSummary: "", - OperationID: "test_response_integer_int8", + OperationID: "test_response_integer_int32", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73026,7 +73035,7 @@ func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = int8 + Response = int32 ) response, err = middleware.HookMiddleware[ Request, @@ -73037,12 +73046,12 @@ func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt8(ctx, request) + response, err = s.h.TestResponseIntegerInt32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt8(ctx, request) + response, err = s.h.TestResponseIntegerInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -73050,7 +73059,7 @@ func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscape return } - if err := encodeTestResponseIntegerInt8Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73059,18 +73068,18 @@ func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscape } } -// handleTestResponseIntegerInt8ArrayRequest handles test_response_integer_int8_array operation. +// handleTestResponseIntegerInt32ArrayRequest handles test_response_integer_int32_array operation. // -// POST /test_response_integer_int8_array -func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int32_array +func (s *Server) handleTestResponseIntegerInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int8_array"), + otelogen.OperationID("test_response_integer_int32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int8_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73095,11 +73104,11 @@ func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt8Array", - ID: "test_response_integer_int8_array", + Name: "TestResponseIntegerInt32Array", + ID: "test_response_integer_int32_array", } ) - request, close, err := s.decodeTestResponseIntegerInt8ArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73115,13 +73124,13 @@ func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsE } }() - var response []int8 + var response []int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt8Array", + OperationName: "TestResponseIntegerInt32Array", OperationSummary: "", - OperationID: "test_response_integer_int8_array", + OperationID: "test_response_integer_int32_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73130,7 +73139,7 @@ func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []int8 + Response = []int32 ) response, err = middleware.HookMiddleware[ Request, @@ -73141,12 +73150,12 @@ func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt8Array(ctx, request) + response, err = s.h.TestResponseIntegerInt32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt8Array(ctx, request) + response, err = s.h.TestResponseIntegerInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -73154,7 +73163,7 @@ func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseIntegerInt8ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73163,18 +73172,18 @@ func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsE } } -// handleTestResponseIntegerInt8ArrayArrayRequest handles test_response_integer_int8_array_array operation. +// handleTestResponseIntegerInt32ArrayArrayRequest handles test_response_integer_int32_array_array operation. // -// POST /test_response_integer_int8_array_array -func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int32_array_array +func (s *Server) handleTestResponseIntegerInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int8_array_array"), + otelogen.OperationID("test_response_integer_int32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int8_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73199,11 +73208,11 @@ func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt8ArrayArray", - ID: "test_response_integer_int8_array_array", + Name: "TestResponseIntegerInt32ArrayArray", + ID: "test_response_integer_int32_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt8ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73219,13 +73228,13 @@ func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, } }() - var response [][]int8 + var response [][]int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt8ArrayArray", + OperationName: "TestResponseIntegerInt32ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_int8_array_array", + OperationID: "test_response_integer_int32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73234,7 +73243,7 @@ func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int8 + Response = [][]int32 ) response, err = middleware.HookMiddleware[ Request, @@ -73245,12 +73254,12 @@ func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt8ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt8ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -73258,7 +73267,7 @@ func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerInt8ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73267,18 +73276,18 @@ func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, } } -// handleTestResponseIntegerInt8NullableRequest handles test_response_integer_int8_nullable operation. +// handleTestResponseIntegerInt32NullableRequest handles test_response_integer_int32_nullable operation. // -// POST /test_response_integer_int8_nullable -func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int32_nullable +func (s *Server) handleTestResponseIntegerInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int8_nullable"), + otelogen.OperationID("test_response_integer_int32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int8_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73303,11 +73312,11 @@ func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt8Nullable", - ID: "test_response_integer_int8_nullable", + Name: "TestResponseIntegerInt32Nullable", + ID: "test_response_integer_int32_nullable", } ) - request, close, err := s.decodeTestResponseIntegerInt8NullableRequest(r) + request, close, err := s.decodeTestResponseIntegerInt32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73323,13 +73332,13 @@ func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, ar } }() - var response NilInt8 + var response NilInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt8Nullable", + OperationName: "TestResponseIntegerInt32Nullable", OperationSummary: "", - OperationID: "test_response_integer_int8_nullable", + OperationID: "test_response_integer_int32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73338,7 +73347,7 @@ func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilInt8 + Response = NilInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -73349,12 +73358,12 @@ func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt8Nullable(ctx, request) + response, err = s.h.TestResponseIntegerInt32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt8Nullable(ctx, request) + response, err = s.h.TestResponseIntegerInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -73362,7 +73371,7 @@ func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, ar return } - if err := encodeTestResponseIntegerInt8NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73371,18 +73380,18 @@ func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, ar } } -// handleTestResponseIntegerInt8NullableArrayRequest handles test_response_integer_int8_nullable_array operation. +// handleTestResponseIntegerInt32NullableArrayRequest handles test_response_integer_int32_nullable_array operation. // -// POST /test_response_integer_int8_nullable_array -func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int32_nullable_array +func (s *Server) handleTestResponseIntegerInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int8_nullable_array"), + otelogen.OperationID("test_response_integer_int32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int8_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73407,11 +73416,11 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt8NullableArray", - ID: "test_response_integer_int8_nullable_array", + Name: "TestResponseIntegerInt32NullableArray", + ID: "test_response_integer_int32_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerInt8NullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73427,13 +73436,13 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]strin } }() - var response []NilInt8 + var response []NilInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt8NullableArray", + OperationName: "TestResponseIntegerInt32NullableArray", OperationSummary: "", - OperationID: "test_response_integer_int8_nullable_array", + OperationID: "test_response_integer_int32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73442,7 +73451,7 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilInt8 + Response = []NilInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -73453,12 +73462,12 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt8NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt8NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -73466,7 +73475,7 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]strin return } - if err := encodeTestResponseIntegerInt8NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73475,18 +73484,18 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]strin } } -// handleTestResponseIntegerInt8NullableArrayArrayRequest handles test_response_integer_int8_nullable_array_array operation. +// handleTestResponseIntegerInt32NullableArrayArrayRequest handles test_response_integer_int32_nullable_array_array operation. // -// POST /test_response_integer_int8_nullable_array_array -func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int32_nullable_array_array +func (s *Server) handleTestResponseIntegerInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_int8_nullable_array_array"), + otelogen.OperationID("test_response_integer_int32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_int8_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73511,11 +73520,11 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerInt8NullableArrayArray", - ID: "test_response_integer_int8_nullable_array_array", + Name: "TestResponseIntegerInt32NullableArrayArray", + ID: "test_response_integer_int32_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerInt8NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73531,13 +73540,13 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0] } }() - var response [][]NilInt8 + var response [][]NilInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerInt8NullableArrayArray", + OperationName: "TestResponseIntegerInt32NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_int8_nullable_array_array", + OperationID: "test_response_integer_int32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73546,7 +73555,7 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilInt8 + Response = [][]NilInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -73557,12 +73566,12 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerInt8NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerInt8NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -73570,7 +73579,7 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseIntegerInt8NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73579,18 +73588,18 @@ func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0] } } -// handleTestResponseIntegerNullableRequest handles test_response_integer_nullable operation. +// handleTestResponseIntegerInt64Request handles test_response_integer_int64 operation. // -// POST /test_response_integer_nullable -func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64 +func (s *Server) handleTestResponseIntegerInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable"), + otelogen.OperationID("test_response_integer_int64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73615,11 +73624,11 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerNullable", - ID: "test_response_integer_nullable", + Name: "TestResponseIntegerInt64", + ID: "test_response_integer_int64", } ) - request, close, err := s.decodeTestResponseIntegerNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerInt64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73635,13 +73644,13 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEs } }() - var response NilInt + var response int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerNullable", + OperationName: "TestResponseIntegerInt64", OperationSummary: "", - OperationID: "test_response_integer_nullable", + OperationID: "test_response_integer_int64", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73650,7 +73659,7 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEs type ( Request = string Params = struct{} - Response = NilInt + Response = int64 ) response, err = middleware.HookMiddleware[ Request, @@ -73661,12 +73670,12 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerNullable(ctx, request) + response, err = s.h.TestResponseIntegerInt64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerNullable(ctx, request) + response, err = s.h.TestResponseIntegerInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -73674,7 +73683,7 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEs return } - if err := encodeTestResponseIntegerNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73683,18 +73692,18 @@ func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEs } } -// handleTestResponseIntegerNullableArrayRequest handles test_response_integer_nullable_array operation. +// handleTestResponseIntegerInt64ArrayRequest handles test_response_integer_int64_array operation. // -// POST /test_response_integer_nullable_array -func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_array +func (s *Server) handleTestResponseIntegerInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable_array"), + otelogen.OperationID("test_response_integer_int64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73719,11 +73728,11 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerNullableArray", - ID: "test_response_integer_nullable_array", + Name: "TestResponseIntegerInt64Array", + ID: "test_response_integer_int64_array", } ) - request, close, err := s.decodeTestResponseIntegerNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73739,13 +73748,13 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, a } }() - var response []NilInt + var response []int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerNullableArray", + OperationName: "TestResponseIntegerInt64Array", OperationSummary: "", - OperationID: "test_response_integer_nullable_array", + OperationID: "test_response_integer_int64_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73754,7 +73763,7 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, a type ( Request = string Params = struct{} - Response = []NilInt + Response = []int64 ) response, err = middleware.HookMiddleware[ Request, @@ -73765,12 +73774,12 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -73778,7 +73787,7 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, a return } - if err := encodeTestResponseIntegerNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73787,18 +73796,18 @@ func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, a } } -// handleTestResponseIntegerNullableArrayArrayRequest handles test_response_integer_nullable_array_array operation. +// handleTestResponseIntegerInt64ArrayArrayRequest handles test_response_integer_int64_array_array operation. // -// POST /test_response_integer_nullable_array_array -func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_array_array +func (s *Server) handleTestResponseIntegerInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_nullable_array_array"), + otelogen.OperationID("test_response_integer_int64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int64_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(), "TestResponseIntegerInt64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73823,11 +73832,11 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerNullableArrayArray", - ID: "test_response_integer_nullable_array_array", + Name: "TestResponseIntegerInt64ArrayArray", + ID: "test_response_integer_int64_array_array", } ) - request, close, err := s.decodeTestResponseIntegerNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73843,13 +73852,13 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri } }() - var response [][]NilInt + var response [][]int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerNullableArrayArray", + OperationName: "TestResponseIntegerInt64ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_nullable_array_array", + OperationID: "test_response_integer_int64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73858,7 +73867,7 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = [][]NilInt + Response = [][]int64 ) response, err = middleware.HookMiddleware[ Request, @@ -73869,12 +73878,12 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -73882,7 +73891,7 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73891,18 +73900,18 @@ func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]stri } } -// handleTestResponseIntegerUintRequest handles test_response_integer_uint operation. +// handleTestResponseIntegerInt64NullableRequest handles test_response_integer_int64_nullable operation. // -// POST /test_response_integer_uint -func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_nullable +func (s *Server) handleTestResponseIntegerInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint"), + otelogen.OperationID("test_response_integer_int64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint"), + semconv.HTTPRouteKey.String("/test_response_integer_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -73927,11 +73936,11 @@ func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint", - ID: "test_response_integer_uint", + Name: "TestResponseIntegerInt64Nullable", + ID: "test_response_integer_int64_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUintRequest(r) + request, close, err := s.decodeTestResponseIntegerInt64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -73947,13 +73956,13 @@ func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscape } }() - var response uint + var response NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint", + OperationName: "TestResponseIntegerInt64Nullable", OperationSummary: "", - OperationID: "test_response_integer_uint", + OperationID: "test_response_integer_int64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -73962,7 +73971,7 @@ func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = uint + Response = NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -73973,12 +73982,12 @@ func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint(ctx, request) + response, err = s.h.TestResponseIntegerInt64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint(ctx, request) + response, err = s.h.TestResponseIntegerInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -73986,7 +73995,7 @@ func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscape return } - if err := encodeTestResponseIntegerUintResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -73995,18 +74004,18 @@ func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscape } } -// handleTestResponseIntegerUint16Request handles test_response_integer_uint16 operation. +// handleTestResponseIntegerInt64NullableArrayRequest handles test_response_integer_int64_nullable_array operation. // -// POST /test_response_integer_uint16 -func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_nullable_array +func (s *Server) handleTestResponseIntegerInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint16"), + otelogen.OperationID("test_response_integer_int64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint16"), + semconv.HTTPRouteKey.String("/test_response_integer_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74031,11 +74040,11 @@ func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint16", - ID: "test_response_integer_uint16", + Name: "TestResponseIntegerInt64NullableArray", + ID: "test_response_integer_int64_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUint16Request(r) + request, close, err := s.decodeTestResponseIntegerInt64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74051,13 +74060,13 @@ func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEsca } }() - var response uint16 + var response []NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint16", + OperationName: "TestResponseIntegerInt64NullableArray", OperationSummary: "", - OperationID: "test_response_integer_uint16", + OperationID: "test_response_integer_int64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74066,7 +74075,7 @@ func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEsca type ( Request = string Params = struct{} - Response = uint16 + Response = []NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -74077,12 +74086,12 @@ func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint16(ctx, request) + response, err = s.h.TestResponseIntegerInt64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint16(ctx, request) + response, err = s.h.TestResponseIntegerInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -74090,7 +74099,7 @@ func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEsca return } - if err := encodeTestResponseIntegerUint16Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74099,18 +74108,18 @@ func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEsca } } -// handleTestResponseIntegerUint16ArrayRequest handles test_response_integer_uint16_array operation. +// handleTestResponseIntegerInt64NullableArrayArrayRequest handles test_response_integer_int64_nullable_array_array operation. // -// POST /test_response_integer_uint16_array -func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int64_nullable_array_array +func (s *Server) handleTestResponseIntegerInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint16_array"), + otelogen.OperationID("test_response_integer_int64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint16_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74135,11 +74144,11 @@ func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint16Array", - ID: "test_response_integer_uint16_array", + Name: "TestResponseIntegerInt64NullableArrayArray", + ID: "test_response_integer_int64_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint16ArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74155,13 +74164,13 @@ func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, arg } }() - var response []uint16 + var response [][]NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint16Array", + OperationName: "TestResponseIntegerInt64NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint16_array", + OperationID: "test_response_integer_int64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74170,7 +74179,7 @@ func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = []uint16 + Response = [][]NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -74181,12 +74190,12 @@ func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint16Array(ctx, request) + response, err = s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint16Array(ctx, request) + response, err = s.h.TestResponseIntegerInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -74194,7 +74203,7 @@ func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, arg return } - if err := encodeTestResponseIntegerUint16ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74203,18 +74212,18 @@ func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, arg } } -// handleTestResponseIntegerUint16ArrayArrayRequest handles test_response_integer_uint16_array_array operation. +// handleTestResponseIntegerInt8Request handles test_response_integer_int8 operation. // -// POST /test_response_integer_uint16_array_array -func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int8 +func (s *Server) handleTestResponseIntegerInt8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint16_array_array"), + otelogen.OperationID("test_response_integer_int8"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint16_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int8"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74239,11 +74248,11 @@ func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint16ArrayArray", - ID: "test_response_integer_uint16_array_array", + Name: "TestResponseIntegerInt8", + ID: "test_response_integer_int8", } ) - request, close, err := s.decodeTestResponseIntegerUint16ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt8Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74259,13 +74268,13 @@ func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string } }() - var response [][]uint16 + var response int8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint16ArrayArray", + OperationName: "TestResponseIntegerInt8", OperationSummary: "", - OperationID: "test_response_integer_uint16_array_array", + OperationID: "test_response_integer_int8", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74274,7 +74283,7 @@ func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = [][]uint16 + Response = int8 ) response, err = middleware.HookMiddleware[ Request, @@ -74285,12 +74294,12 @@ func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint16ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt8(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint16ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt8(ctx, request) } if err != nil { recordError("Internal", err) @@ -74298,7 +74307,7 @@ func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string return } - if err := encodeTestResponseIntegerUint16ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt8Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74307,18 +74316,18 @@ func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string } } -// handleTestResponseIntegerUint16NullableRequest handles test_response_integer_uint16_nullable operation. +// handleTestResponseIntegerInt8ArrayRequest handles test_response_integer_int8_array operation. // -// POST /test_response_integer_uint16_nullable -func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int8_array +func (s *Server) handleTestResponseIntegerInt8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint16_nullable"), + otelogen.OperationID("test_response_integer_int8_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint16_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_int8_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74343,11 +74352,11 @@ func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint16Nullable", - ID: "test_response_integer_uint16_nullable", + Name: "TestResponseIntegerInt8Array", + ID: "test_response_integer_int8_array", } ) - request, close, err := s.decodeTestResponseIntegerUint16NullableRequest(r) + request, close, err := s.decodeTestResponseIntegerInt8ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74363,13 +74372,13 @@ func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, } }() - var response NilUint16 + var response []int8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint16Nullable", + OperationName: "TestResponseIntegerInt8Array", OperationSummary: "", - OperationID: "test_response_integer_uint16_nullable", + OperationID: "test_response_integer_int8_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74378,7 +74387,7 @@ func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilUint16 + Response = []int8 ) response, err = middleware.HookMiddleware[ Request, @@ -74389,12 +74398,12 @@ func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint16Nullable(ctx, request) + response, err = s.h.TestResponseIntegerInt8Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint16Nullable(ctx, request) + response, err = s.h.TestResponseIntegerInt8Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -74402,7 +74411,7 @@ func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, return } - if err := encodeTestResponseIntegerUint16NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt8ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74411,18 +74420,18 @@ func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, } } -// handleTestResponseIntegerUint16NullableArrayRequest handles test_response_integer_uint16_nullable_array operation. +// handleTestResponseIntegerInt8ArrayArrayRequest handles test_response_integer_int8_array_array operation. // -// POST /test_response_integer_uint16_nullable_array -func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int8_array_array +func (s *Server) handleTestResponseIntegerInt8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint16_nullable_array"), + otelogen.OperationID("test_response_integer_int8_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint16_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int8_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74447,11 +74456,11 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint16NullableArray", - ID: "test_response_integer_uint16_nullable_array", + Name: "TestResponseIntegerInt8ArrayArray", + ID: "test_response_integer_int8_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint16NullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt8ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74467,13 +74476,13 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]str } }() - var response []NilUint16 + var response [][]int8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint16NullableArray", + OperationName: "TestResponseIntegerInt8ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint16_nullable_array", + OperationID: "test_response_integer_int8_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74482,7 +74491,7 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = []NilUint16 + Response = [][]int8 ) response, err = middleware.HookMiddleware[ Request, @@ -74493,12 +74502,12 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint16NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt8ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint16NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerInt8ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -74506,7 +74515,7 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]str return } - if err := encodeTestResponseIntegerUint16NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt8ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74515,18 +74524,18 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]str } } -// handleTestResponseIntegerUint16NullableArrayArrayRequest handles test_response_integer_uint16_nullable_array_array operation. +// handleTestResponseIntegerInt8NullableRequest handles test_response_integer_int8_nullable operation. // -// POST /test_response_integer_uint16_nullable_array_array -func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int8_nullable +func (s *Server) handleTestResponseIntegerInt8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint16_nullable_array_array"), + otelogen.OperationID("test_response_integer_int8_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint16_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int8_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74551,11 +74560,11 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint16NullableArrayArray", - ID: "test_response_integer_uint16_nullable_array_array", + Name: "TestResponseIntegerInt8Nullable", + ID: "test_response_integer_int8_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUint16NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt8NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74571,13 +74580,13 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [ } }() - var response [][]NilUint16 + var response NilInt8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint16NullableArrayArray", + OperationName: "TestResponseIntegerInt8Nullable", OperationSummary: "", - OperationID: "test_response_integer_uint16_nullable_array_array", + OperationID: "test_response_integer_int8_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74586,7 +74595,7 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [ type ( Request = string Params = struct{} - Response = [][]NilUint16 + Response = NilInt8 ) response, err = middleware.HookMiddleware[ Request, @@ -74597,12 +74606,12 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint16NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt8Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint16NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerInt8Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -74610,7 +74619,7 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [ return } - if err := encodeTestResponseIntegerUint16NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt8NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74619,18 +74628,18 @@ func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [ } } -// handleTestResponseIntegerUint32Request handles test_response_integer_uint32 operation. +// handleTestResponseIntegerInt8NullableArrayRequest handles test_response_integer_int8_nullable_array operation. // -// POST /test_response_integer_uint32 -func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int8_nullable_array +func (s *Server) handleTestResponseIntegerInt8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint32"), + otelogen.OperationID("test_response_integer_int8_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint32"), + semconv.HTTPRouteKey.String("/test_response_integer_int8_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74655,11 +74664,11 @@ func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint32", - ID: "test_response_integer_uint32", + Name: "TestResponseIntegerInt8NullableArray", + ID: "test_response_integer_int8_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUint32Request(r) + request, close, err := s.decodeTestResponseIntegerInt8NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74675,13 +74684,13 @@ func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEsca } }() - var response uint32 + var response []NilInt8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint32", + OperationName: "TestResponseIntegerInt8NullableArray", OperationSummary: "", - OperationID: "test_response_integer_uint32", + OperationID: "test_response_integer_int8_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74690,7 +74699,7 @@ func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEsca type ( Request = string Params = struct{} - Response = uint32 + Response = []NilInt8 ) response, err = middleware.HookMiddleware[ Request, @@ -74701,12 +74710,12 @@ func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint32(ctx, request) + response, err = s.h.TestResponseIntegerInt8NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint32(ctx, request) + response, err = s.h.TestResponseIntegerInt8NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -74714,7 +74723,7 @@ func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEsca return } - if err := encodeTestResponseIntegerUint32Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt8NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74723,18 +74732,18 @@ func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEsca } } -// handleTestResponseIntegerUint32ArrayRequest handles test_response_integer_uint32_array operation. +// handleTestResponseIntegerInt8NullableArrayArrayRequest handles test_response_integer_int8_nullable_array_array operation. // -// POST /test_response_integer_uint32_array -func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_int8_nullable_array_array +func (s *Server) handleTestResponseIntegerInt8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint32_array"), + otelogen.OperationID("test_response_integer_int8_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint32_array"), + semconv.HTTPRouteKey.String("/test_response_integer_int8_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerInt8NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74759,11 +74768,11 @@ func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint32Array", - ID: "test_response_integer_uint32_array", + Name: "TestResponseIntegerInt8NullableArrayArray", + ID: "test_response_integer_int8_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint32ArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerInt8NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74779,13 +74788,13 @@ func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, arg } }() - var response []uint32 + var response [][]NilInt8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint32Array", + OperationName: "TestResponseIntegerInt8NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint32_array", + OperationID: "test_response_integer_int8_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74794,7 +74803,7 @@ func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = []uint32 + Response = [][]NilInt8 ) response, err = middleware.HookMiddleware[ Request, @@ -74805,12 +74814,12 @@ func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint32Array(ctx, request) + response, err = s.h.TestResponseIntegerInt8NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint32Array(ctx, request) + response, err = s.h.TestResponseIntegerInt8NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -74818,7 +74827,7 @@ func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, arg return } - if err := encodeTestResponseIntegerUint32ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerInt8NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74827,18 +74836,18 @@ func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, arg } } -// handleTestResponseIntegerUint32ArrayArrayRequest handles test_response_integer_uint32_array_array operation. +// handleTestResponseIntegerNullableRequest handles test_response_integer_nullable operation. // -// POST /test_response_integer_uint32_array_array -func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_nullable +func (s *Server) handleTestResponseIntegerNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint32_array_array"), + otelogen.OperationID("test_response_integer_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint32_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74863,11 +74872,11 @@ func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint32ArrayArray", - ID: "test_response_integer_uint32_array_array", + Name: "TestResponseIntegerNullable", + ID: "test_response_integer_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUint32ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74883,13 +74892,13 @@ func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string } }() - var response [][]uint32 + var response NilInt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint32ArrayArray", + OperationName: "TestResponseIntegerNullable", OperationSummary: "", - OperationID: "test_response_integer_uint32_array_array", + OperationID: "test_response_integer_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -74898,7 +74907,7 @@ func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = [][]uint32 + Response = NilInt ) response, err = middleware.HookMiddleware[ Request, @@ -74909,12 +74918,12 @@ func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint32ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint32ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -74922,7 +74931,7 @@ func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string return } - if err := encodeTestResponseIntegerUint32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -74931,18 +74940,18 @@ func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string } } -// handleTestResponseIntegerUint32NullableRequest handles test_response_integer_uint32_nullable operation. +// handleTestResponseIntegerNullableArrayRequest handles test_response_integer_nullable_array operation. // -// POST /test_response_integer_uint32_nullable -func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_nullable_array +func (s *Server) handleTestResponseIntegerNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint32_nullable"), + otelogen.OperationID("test_response_integer_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint32_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -74967,11 +74976,11 @@ func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint32Nullable", - ID: "test_response_integer_uint32_nullable", + Name: "TestResponseIntegerNullableArray", + ID: "test_response_integer_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUint32NullableRequest(r) + request, close, err := s.decodeTestResponseIntegerNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -74987,13 +74996,13 @@ func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, } }() - var response NilUint32 + var response []NilInt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint32Nullable", + OperationName: "TestResponseIntegerNullableArray", OperationSummary: "", - OperationID: "test_response_integer_uint32_nullable", + OperationID: "test_response_integer_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75002,7 +75011,7 @@ func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilUint32 + Response = []NilInt ) response, err = middleware.HookMiddleware[ Request, @@ -75013,12 +75022,12 @@ func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint32Nullable(ctx, request) + response, err = s.h.TestResponseIntegerNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint32Nullable(ctx, request) + response, err = s.h.TestResponseIntegerNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -75026,7 +75035,7 @@ func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, return } - if err := encodeTestResponseIntegerUint32NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75035,18 +75044,18 @@ func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, } } -// handleTestResponseIntegerUint32NullableArrayRequest handles test_response_integer_uint32_nullable_array operation. +// handleTestResponseIntegerNullableArrayArrayRequest handles test_response_integer_nullable_array_array operation. // -// POST /test_response_integer_uint32_nullable_array -func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_nullable_array_array +func (s *Server) handleTestResponseIntegerNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint32_nullable_array"), + otelogen.OperationID("test_response_integer_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint32_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75071,11 +75080,11 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint32NullableArray", - ID: "test_response_integer_uint32_nullable_array", + Name: "TestResponseIntegerNullableArrayArray", + ID: "test_response_integer_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint32NullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75091,13 +75100,13 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]str } }() - var response []NilUint32 + var response [][]NilInt if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint32NullableArray", + OperationName: "TestResponseIntegerNullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint32_nullable_array", + OperationID: "test_response_integer_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75106,7 +75115,7 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = []NilUint32 + Response = [][]NilInt ) response, err = middleware.HookMiddleware[ Request, @@ -75117,12 +75126,12 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint32NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint32NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -75130,7 +75139,7 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]str return } - if err := encodeTestResponseIntegerUint32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75139,18 +75148,18 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]str } } -// handleTestResponseIntegerUint32NullableArrayArrayRequest handles test_response_integer_uint32_nullable_array_array operation. +// handleTestResponseIntegerUintRequest handles test_response_integer_uint operation. // -// POST /test_response_integer_uint32_nullable_array_array -func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint +func (s *Server) handleTestResponseIntegerUintRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint32_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75175,11 +75184,11 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint32NullableArrayArray", - ID: "test_response_integer_uint32_nullable_array_array", + Name: "TestResponseIntegerUint", + ID: "test_response_integer_uint", } ) - request, close, err := s.decodeTestResponseIntegerUint32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUintRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75195,13 +75204,13 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [ } }() - var response [][]NilUint32 + var response uint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint32NullableArrayArray", + OperationName: "TestResponseIntegerUint", OperationSummary: "", - OperationID: "test_response_integer_uint32_nullable_array_array", + OperationID: "test_response_integer_uint", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75210,7 +75219,7 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [ type ( Request = string Params = struct{} - Response = [][]NilUint32 + Response = uint ) response, err = middleware.HookMiddleware[ Request, @@ -75221,12 +75230,12 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint(ctx, request) } if err != nil { recordError("Internal", err) @@ -75234,7 +75243,7 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [ return } - if err := encodeTestResponseIntegerUint32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75243,18 +75252,18 @@ func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [ } } -// handleTestResponseIntegerUint64Request handles test_response_integer_uint64 operation. +// handleTestResponseIntegerUint16Request handles test_response_integer_uint16 operation. // -// POST /test_response_integer_uint64 -func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint16 +func (s *Server) handleTestResponseIntegerUint16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint64"), + otelogen.OperationID("test_response_integer_uint16"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint64"), + semconv.HTTPRouteKey.String("/test_response_integer_uint16"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75279,11 +75288,11 @@ func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint64", - ID: "test_response_integer_uint64", + Name: "TestResponseIntegerUint16", + ID: "test_response_integer_uint16", } ) - request, close, err := s.decodeTestResponseIntegerUint64Request(r) + request, close, err := s.decodeTestResponseIntegerUint16Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75299,13 +75308,13 @@ func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEsca } }() - var response uint64 + var response uint16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint64", + OperationName: "TestResponseIntegerUint16", OperationSummary: "", - OperationID: "test_response_integer_uint64", + OperationID: "test_response_integer_uint16", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75314,7 +75323,7 @@ func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEsca type ( Request = string Params = struct{} - Response = uint64 + Response = uint16 ) response, err = middleware.HookMiddleware[ Request, @@ -75325,12 +75334,12 @@ func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint64(ctx, request) + response, err = s.h.TestResponseIntegerUint16(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint64(ctx, request) + response, err = s.h.TestResponseIntegerUint16(ctx, request) } if err != nil { recordError("Internal", err) @@ -75338,7 +75347,7 @@ func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEsca return } - if err := encodeTestResponseIntegerUint64Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint16Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75347,18 +75356,18 @@ func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEsca } } -// handleTestResponseIntegerUint64ArrayRequest handles test_response_integer_uint64_array operation. +// handleTestResponseIntegerUint16ArrayRequest handles test_response_integer_uint16_array operation. // -// POST /test_response_integer_uint64_array -func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint16_array +func (s *Server) handleTestResponseIntegerUint16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint64_array"), + otelogen.OperationID("test_response_integer_uint16_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint64_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint16_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75383,11 +75392,11 @@ func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint64Array", - ID: "test_response_integer_uint64_array", + Name: "TestResponseIntegerUint16Array", + ID: "test_response_integer_uint16_array", } ) - request, close, err := s.decodeTestResponseIntegerUint64ArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint16ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75403,13 +75412,13 @@ func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, arg } }() - var response []uint64 + var response []uint16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint64Array", + OperationName: "TestResponseIntegerUint16Array", OperationSummary: "", - OperationID: "test_response_integer_uint64_array", + OperationID: "test_response_integer_uint16_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75418,7 +75427,7 @@ func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = []uint64 + Response = []uint16 ) response, err = middleware.HookMiddleware[ Request, @@ -75429,12 +75438,12 @@ func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint64Array(ctx, request) + response, err = s.h.TestResponseIntegerUint16Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint64Array(ctx, request) + response, err = s.h.TestResponseIntegerUint16Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -75442,7 +75451,7 @@ func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, arg return } - if err := encodeTestResponseIntegerUint64ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint16ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75451,18 +75460,18 @@ func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, arg } } -// handleTestResponseIntegerUint64ArrayArrayRequest handles test_response_integer_uint64_array_array operation. +// handleTestResponseIntegerUint16ArrayArrayRequest handles test_response_integer_uint16_array_array operation. // -// POST /test_response_integer_uint64_array_array -func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint16_array_array +func (s *Server) handleTestResponseIntegerUint16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint64_array_array"), + otelogen.OperationID("test_response_integer_uint16_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint64_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint16_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75487,11 +75496,11 @@ func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint64ArrayArray", - ID: "test_response_integer_uint64_array_array", + Name: "TestResponseIntegerUint16ArrayArray", + ID: "test_response_integer_uint16_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint64ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint16ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75507,13 +75516,13 @@ func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string } }() - var response [][]uint64 + var response [][]uint16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint64ArrayArray", + OperationName: "TestResponseIntegerUint16ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint64_array_array", + OperationID: "test_response_integer_uint16_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75522,7 +75531,7 @@ func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = [][]uint64 + Response = [][]uint16 ) response, err = middleware.HookMiddleware[ Request, @@ -75533,12 +75542,12 @@ func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint64ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint16ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint64ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint16ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -75546,7 +75555,7 @@ func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string return } - if err := encodeTestResponseIntegerUint64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint16ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75555,18 +75564,18 @@ func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string } } -// handleTestResponseIntegerUint64NullableRequest handles test_response_integer_uint64_nullable operation. +// handleTestResponseIntegerUint16NullableRequest handles test_response_integer_uint16_nullable operation. // -// POST /test_response_integer_uint64_nullable -func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint16_nullable +func (s *Server) handleTestResponseIntegerUint16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint64_nullable"), + otelogen.OperationID("test_response_integer_uint16_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint64_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_uint16_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75591,11 +75600,11 @@ func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint64Nullable", - ID: "test_response_integer_uint64_nullable", + Name: "TestResponseIntegerUint16Nullable", + ID: "test_response_integer_uint16_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUint64NullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUint16NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75611,13 +75620,13 @@ func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, } }() - var response NilUint64 + var response NilUint16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint64Nullable", + OperationName: "TestResponseIntegerUint16Nullable", OperationSummary: "", - OperationID: "test_response_integer_uint64_nullable", + OperationID: "test_response_integer_uint16_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75626,7 +75635,7 @@ func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilUint64 + Response = NilUint16 ) response, err = middleware.HookMiddleware[ Request, @@ -75637,12 +75646,12 @@ func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint64Nullable(ctx, request) + response, err = s.h.TestResponseIntegerUint16Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint64Nullable(ctx, request) + response, err = s.h.TestResponseIntegerUint16Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -75650,7 +75659,7 @@ func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, return } - if err := encodeTestResponseIntegerUint64NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint16NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75659,18 +75668,18 @@ func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, } } -// handleTestResponseIntegerUint64NullableArrayRequest handles test_response_integer_uint64_nullable_array operation. +// handleTestResponseIntegerUint16NullableArrayRequest handles test_response_integer_uint16_nullable_array operation. // -// POST /test_response_integer_uint64_nullable_array -func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint16_nullable_array +func (s *Server) handleTestResponseIntegerUint16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint64_nullable_array"), + otelogen.OperationID("test_response_integer_uint16_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint64_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint16_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75695,11 +75704,11 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint64NullableArray", - ID: "test_response_integer_uint64_nullable_array", + Name: "TestResponseIntegerUint16NullableArray", + ID: "test_response_integer_uint16_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUint64NullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint16NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75715,13 +75724,13 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]str } }() - var response []NilUint64 + var response []NilUint16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint64NullableArray", + OperationName: "TestResponseIntegerUint16NullableArray", OperationSummary: "", - OperationID: "test_response_integer_uint64_nullable_array", + OperationID: "test_response_integer_uint16_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75730,7 +75739,7 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = []NilUint64 + Response = []NilUint16 ) response, err = middleware.HookMiddleware[ Request, @@ -75741,12 +75750,12 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint64NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUint16NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint64NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUint16NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -75754,7 +75763,7 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]str return } - if err := encodeTestResponseIntegerUint64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint16NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75763,18 +75772,18 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]str } } -// handleTestResponseIntegerUint64NullableArrayArrayRequest handles test_response_integer_uint64_nullable_array_array operation. +// handleTestResponseIntegerUint16NullableArrayArrayRequest handles test_response_integer_uint16_nullable_array_array operation. // -// POST /test_response_integer_uint64_nullable_array_array -func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint16_nullable_array_array +func (s *Server) handleTestResponseIntegerUint16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint64_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint16_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint16_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint16NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75799,11 +75808,11 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint64NullableArrayArray", - ID: "test_response_integer_uint64_nullable_array_array", + Name: "TestResponseIntegerUint16NullableArrayArray", + ID: "test_response_integer_uint16_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint16NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75819,13 +75828,13 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [ } }() - var response [][]NilUint64 + var response [][]NilUint16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint64NullableArrayArray", + OperationName: "TestResponseIntegerUint16NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint64_nullable_array_array", + OperationID: "test_response_integer_uint16_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75834,7 +75843,7 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [ type ( Request = string Params = struct{} - Response = [][]NilUint64 + Response = [][]NilUint16 ) response, err = middleware.HookMiddleware[ Request, @@ -75845,12 +75854,12 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint16NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint16NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -75858,7 +75867,7 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [ return } - if err := encodeTestResponseIntegerUint64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint16NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75867,18 +75876,18 @@ func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [ } } -// handleTestResponseIntegerUint8Request handles test_response_integer_uint8 operation. +// handleTestResponseIntegerUint32Request handles test_response_integer_uint32 operation. // -// POST /test_response_integer_uint8 -func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32 +func (s *Server) handleTestResponseIntegerUint32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint8"), + otelogen.OperationID("test_response_integer_uint32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint8"), + semconv.HTTPRouteKey.String("/test_response_integer_uint32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -75903,11 +75912,11 @@ func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint8", - ID: "test_response_integer_uint8", + Name: "TestResponseIntegerUint32", + ID: "test_response_integer_uint32", } ) - request, close, err := s.decodeTestResponseIntegerUint8Request(r) + request, close, err := s.decodeTestResponseIntegerUint32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -75923,13 +75932,13 @@ func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscap } }() - var response uint8 + var response uint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint8", + OperationName: "TestResponseIntegerUint32", OperationSummary: "", - OperationID: "test_response_integer_uint8", + OperationID: "test_response_integer_uint32", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -75938,7 +75947,7 @@ func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = uint8 + Response = uint32 ) response, err = middleware.HookMiddleware[ Request, @@ -75949,12 +75958,12 @@ func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint8(ctx, request) + response, err = s.h.TestResponseIntegerUint32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint8(ctx, request) + response, err = s.h.TestResponseIntegerUint32(ctx, request) } if err != nil { recordError("Internal", err) @@ -75962,7 +75971,7 @@ func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscap return } - if err := encodeTestResponseIntegerUint8Response(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -75971,18 +75980,18 @@ func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscap } } -// handleTestResponseIntegerUint8ArrayRequest handles test_response_integer_uint8_array operation. +// handleTestResponseIntegerUint32ArrayRequest handles test_response_integer_uint32_array operation. // -// POST /test_response_integer_uint8_array -func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_array +func (s *Server) handleTestResponseIntegerUint32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint8_array"), + otelogen.OperationID("test_response_integer_uint32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint8_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76007,11 +76016,11 @@ func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint8Array", - ID: "test_response_integer_uint8_array", + Name: "TestResponseIntegerUint32Array", + ID: "test_response_integer_uint32_array", } ) - request, close, err := s.decodeTestResponseIntegerUint8ArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76027,13 +76036,13 @@ func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, args } }() - var response []uint8 + var response []uint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint8Array", + OperationName: "TestResponseIntegerUint32Array", OperationSummary: "", - OperationID: "test_response_integer_uint8_array", + OperationID: "test_response_integer_uint32_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76042,7 +76051,7 @@ func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = []uint8 + Response = []uint32 ) response, err = middleware.HookMiddleware[ Request, @@ -76053,12 +76062,12 @@ func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint8Array(ctx, request) + response, err = s.h.TestResponseIntegerUint32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint8Array(ctx, request) + response, err = s.h.TestResponseIntegerUint32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -76066,7 +76075,7 @@ func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, args return } - if err := encodeTestResponseIntegerUint8ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76075,18 +76084,18 @@ func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, args } } -// handleTestResponseIntegerUint8ArrayArrayRequest handles test_response_integer_uint8_array_array operation. +// handleTestResponseIntegerUint32ArrayArrayRequest handles test_response_integer_uint32_array_array operation. // -// POST /test_response_integer_uint8_array_array -func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_array_array +func (s *Server) handleTestResponseIntegerUint32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint8_array_array"), + otelogen.OperationID("test_response_integer_uint32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint8_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76111,11 +76120,11 @@ func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint8ArrayArray", - ID: "test_response_integer_uint8_array_array", + Name: "TestResponseIntegerUint32ArrayArray", + ID: "test_response_integer_uint32_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint8ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76131,13 +76140,13 @@ func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, } }() - var response [][]uint8 + var response [][]uint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint8ArrayArray", + OperationName: "TestResponseIntegerUint32ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint8_array_array", + OperationID: "test_response_integer_uint32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76146,7 +76155,7 @@ func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]uint8 + Response = [][]uint32 ) response, err = middleware.HookMiddleware[ Request, @@ -76157,12 +76166,12 @@ func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint8ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint8ArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -76170,7 +76179,7 @@ func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerUint8ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76179,18 +76188,18 @@ func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, } } -// handleTestResponseIntegerUint8NullableRequest handles test_response_integer_uint8_nullable operation. +// handleTestResponseIntegerUint32NullableRequest handles test_response_integer_uint32_nullable operation. // -// POST /test_response_integer_uint8_nullable -func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_nullable +func (s *Server) handleTestResponseIntegerUint32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint8_nullable"), + otelogen.OperationID("test_response_integer_uint32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint8_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_uint32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76215,11 +76224,11 @@ func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint8Nullable", - ID: "test_response_integer_uint8_nullable", + Name: "TestResponseIntegerUint32Nullable", + ID: "test_response_integer_uint32_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUint8NullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUint32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76235,13 +76244,13 @@ func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, a } }() - var response NilUint8 + var response NilUint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint8Nullable", + OperationName: "TestResponseIntegerUint32Nullable", OperationSummary: "", - OperationID: "test_response_integer_uint8_nullable", + OperationID: "test_response_integer_uint32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76250,7 +76259,7 @@ func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, a type ( Request = string Params = struct{} - Response = NilUint8 + Response = NilUint32 ) response, err = middleware.HookMiddleware[ Request, @@ -76261,12 +76270,12 @@ func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint8Nullable(ctx, request) + response, err = s.h.TestResponseIntegerUint32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint8Nullable(ctx, request) + response, err = s.h.TestResponseIntegerUint32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -76274,7 +76283,7 @@ func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, a return } - if err := encodeTestResponseIntegerUint8NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76283,18 +76292,18 @@ func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, a } } -// handleTestResponseIntegerUint8NullableArrayRequest handles test_response_integer_uint8_nullable_array operation. +// handleTestResponseIntegerUint32NullableArrayRequest handles test_response_integer_uint32_nullable_array operation. // -// POST /test_response_integer_uint8_nullable_array -func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_nullable_array +func (s *Server) handleTestResponseIntegerUint32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint8_nullable_array"), + otelogen.OperationID("test_response_integer_uint32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint8_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76319,11 +76328,11 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint8NullableArray", - ID: "test_response_integer_uint8_nullable_array", + Name: "TestResponseIntegerUint32NullableArray", + ID: "test_response_integer_uint32_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUint8NullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76339,13 +76348,13 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]stri } }() - var response []NilUint8 + var response []NilUint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint8NullableArray", + OperationName: "TestResponseIntegerUint32NullableArray", OperationSummary: "", - OperationID: "test_response_integer_uint8_nullable_array", + OperationID: "test_response_integer_uint32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76354,7 +76363,7 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilUint8 + Response = []NilUint32 ) response, err = middleware.HookMiddleware[ Request, @@ -76365,12 +76374,12 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint8NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint8NullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -76378,7 +76387,7 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerUint8NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76387,18 +76396,18 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]stri } } -// handleTestResponseIntegerUint8NullableArrayArrayRequest handles test_response_integer_uint8_nullable_array_array operation. +// handleTestResponseIntegerUint32NullableArrayArrayRequest handles test_response_integer_uint32_nullable_array_array operation. // -// POST /test_response_integer_uint8_nullable_array_array -func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint32_nullable_array_array +func (s *Server) handleTestResponseIntegerUint32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint8_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint8_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76423,11 +76432,11 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUint8NullableArrayArray", - ID: "test_response_integer_uint8_nullable_array_array", + Name: "TestResponseIntegerUint32NullableArrayArray", + ID: "test_response_integer_uint32_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUint8NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76443,13 +76452,13 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0 } }() - var response [][]NilUint8 + var response [][]NilUint32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUint8NullableArrayArray", + OperationName: "TestResponseIntegerUint32NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint8_nullable_array_array", + OperationID: "test_response_integer_uint32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76458,7 +76467,7 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilUint8 + Response = [][]NilUint32 ) response, err = middleware.HookMiddleware[ Request, @@ -76469,12 +76478,12 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUint8NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUint8NullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -76482,7 +76491,7 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseIntegerUint8NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76491,18 +76500,18 @@ func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0 } } -// handleTestResponseIntegerUintArrayRequest handles test_response_integer_uint_array operation. +// handleTestResponseIntegerUint64Request handles test_response_integer_uint64 operation. // -// POST /test_response_integer_uint_array -func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64 +func (s *Server) handleTestResponseIntegerUint64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint_array"), + otelogen.OperationID("test_response_integer_uint64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76527,11 +76536,11 @@ func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUintArray", - ID: "test_response_integer_uint_array", + Name: "TestResponseIntegerUint64", + ID: "test_response_integer_uint64", } ) - request, close, err := s.decodeTestResponseIntegerUintArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76547,13 +76556,13 @@ func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsE } }() - var response []uint + var response uint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUintArray", + OperationName: "TestResponseIntegerUint64", OperationSummary: "", - OperationID: "test_response_integer_uint_array", + OperationID: "test_response_integer_uint64", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76562,7 +76571,7 @@ func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []uint + Response = uint64 ) response, err = middleware.HookMiddleware[ Request, @@ -76573,12 +76582,12 @@ func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUintArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUintArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64(ctx, request) } if err != nil { recordError("Internal", err) @@ -76586,7 +76595,7 @@ func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseIntegerUintArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76595,18 +76604,18 @@ func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsE } } -// handleTestResponseIntegerUintArrayArrayRequest handles test_response_integer_uint_array_array operation. +// handleTestResponseIntegerUint64ArrayRequest handles test_response_integer_uint64_array operation. // -// POST /test_response_integer_uint_array_array -func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_array +func (s *Server) handleTestResponseIntegerUint64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint_array_array"), + otelogen.OperationID("test_response_integer_uint64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76631,11 +76640,11 @@ func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUintArrayArray", - ID: "test_response_integer_uint_array_array", + Name: "TestResponseIntegerUint64Array", + ID: "test_response_integer_uint64_array", } ) - request, close, err := s.decodeTestResponseIntegerUintArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76651,13 +76660,13 @@ func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, } }() - var response [][]uint + var response []uint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUintArrayArray", + OperationName: "TestResponseIntegerUint64Array", OperationSummary: "", - OperationID: "test_response_integer_uint_array_array", + OperationID: "test_response_integer_uint64_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76666,7 +76675,7 @@ func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]uint + Response = []uint64 ) response, err = middleware.HookMiddleware[ Request, @@ -76677,12 +76686,12 @@ func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUintArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUintArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -76690,7 +76699,7 @@ func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerUintArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76699,18 +76708,18 @@ func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, } } -// handleTestResponseIntegerUintNullableRequest handles test_response_integer_uint_nullable operation. +// handleTestResponseIntegerUint64ArrayArrayRequest handles test_response_integer_uint64_array_array operation. // -// POST /test_response_integer_uint_nullable -func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_array_array +func (s *Server) handleTestResponseIntegerUint64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint_nullable"), + otelogen.OperationID("test_response_integer_uint64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_uint64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76735,11 +76744,11 @@ func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUintNullable", - ID: "test_response_integer_uint_nullable", + Name: "TestResponseIntegerUint64ArrayArray", + ID: "test_response_integer_uint64_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUintNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUint64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76755,13 +76764,13 @@ func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, ar } }() - var response NilUint + var response [][]uint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUintNullable", + OperationName: "TestResponseIntegerUint64ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_uint_nullable", + OperationID: "test_response_integer_uint64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76770,7 +76779,7 @@ func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilUint + Response = [][]uint64 ) response, err = middleware.HookMiddleware[ Request, @@ -76781,12 +76790,12 @@ func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUintNullable(ctx, request) + response, err = s.h.TestResponseIntegerUint64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUintNullable(ctx, request) + response, err = s.h.TestResponseIntegerUint64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -76794,7 +76803,7 @@ func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, ar return } - if err := encodeTestResponseIntegerUintNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76803,18 +76812,18 @@ func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, ar } } -// handleTestResponseIntegerUintNullableArrayRequest handles test_response_integer_uint_nullable_array operation. +// handleTestResponseIntegerUint64NullableRequest handles test_response_integer_uint64_nullable operation. // -// POST /test_response_integer_uint_nullable_array -func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_nullable +func (s *Server) handleTestResponseIntegerUint64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint_nullable_array"), + otelogen.OperationID("test_response_integer_uint64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76839,11 +76848,11 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUintNullableArray", - ID: "test_response_integer_uint_nullable_array", + Name: "TestResponseIntegerUint64Nullable", + ID: "test_response_integer_uint64_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUintNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76859,13 +76868,13 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]strin } }() - var response []NilUint + var response NilUint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUintNullableArray", + OperationName: "TestResponseIntegerUint64Nullable", OperationSummary: "", - OperationID: "test_response_integer_uint_nullable_array", + OperationID: "test_response_integer_uint64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76874,7 +76883,7 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilUint + Response = NilUint64 ) response, err = middleware.HookMiddleware[ Request, @@ -76885,12 +76894,12 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUintNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUintNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -76898,7 +76907,7 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]strin return } - if err := encodeTestResponseIntegerUintNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -76907,18 +76916,18 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]strin } } -// handleTestResponseIntegerUintNullableArrayArrayRequest handles test_response_integer_uint_nullable_array_array operation. +// handleTestResponseIntegerUint64NullableArrayRequest handles test_response_integer_uint64_nullable_array operation. // -// POST /test_response_integer_uint_nullable_array_array -func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_nullable_array +func (s *Server) handleTestResponseIntegerUint64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_uint_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_uint_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -76943,11 +76952,11 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUintNullableArrayArray", - ID: "test_response_integer_uint_nullable_array_array", + Name: "TestResponseIntegerUint64NullableArray", + ID: "test_response_integer_uint64_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUintNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -76963,13 +76972,13 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0] } }() - var response [][]NilUint + var response []NilUint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUintNullableArrayArray", + OperationName: "TestResponseIntegerUint64NullableArray", OperationSummary: "", - OperationID: "test_response_integer_uint_nullable_array_array", + OperationID: "test_response_integer_uint64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -76978,7 +76987,7 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilUint + Response = []NilUint64 ) response, err = middleware.HookMiddleware[ Request, @@ -76989,12 +76998,12 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUintNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUintNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -77002,7 +77011,7 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseIntegerUintNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77011,18 +77020,18 @@ func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0] } } -// handleTestResponseIntegerUnixRequest handles test_response_integer_unix operation. +// handleTestResponseIntegerUint64NullableArrayArrayRequest handles test_response_integer_uint64_nullable_array_array operation. // -// POST /test_response_integer_unix -func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint64_nullable_array_array +func (s *Server) handleTestResponseIntegerUint64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix"), + otelogen.OperationID("test_response_integer_uint64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix"), + semconv.HTTPRouteKey.String("/test_response_integer_uint64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnix", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77047,11 +77056,11 @@ func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnix", - ID: "test_response_integer_unix", + Name: "TestResponseIntegerUint64NullableArrayArray", + ID: "test_response_integer_uint64_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixRequest(r) + request, close, err := s.decodeTestResponseIntegerUint64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77067,13 +77076,13 @@ func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscape } }() - var response time.Time + var response [][]NilUint64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnix", + OperationName: "TestResponseIntegerUint64NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix", + OperationID: "test_response_integer_uint64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77082,7 +77091,7 @@ func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = time.Time + Response = [][]NilUint64 ) response, err = middleware.HookMiddleware[ Request, @@ -77093,12 +77102,12 @@ func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnix(ctx, request) + response, err = s.h.TestResponseIntegerUint64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnix(ctx, request) + response, err = s.h.TestResponseIntegerUint64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -77106,7 +77115,7 @@ func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscape return } - if err := encodeTestResponseIntegerUnixResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77115,18 +77124,18 @@ func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscape } } -// handleTestResponseIntegerUnixArrayRequest handles test_response_integer_unix_array operation. +// handleTestResponseIntegerUint8Request handles test_response_integer_uint8 operation. // -// POST /test_response_integer_unix_array -func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint8 +func (s *Server) handleTestResponseIntegerUint8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix_array"), + otelogen.OperationID("test_response_integer_uint8"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint8"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77151,11 +77160,11 @@ func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixArray", - ID: "test_response_integer_unix_array", + Name: "TestResponseIntegerUint8", + ID: "test_response_integer_uint8", } ) - request, close, err := s.decodeTestResponseIntegerUnixArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint8Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77171,13 +77180,13 @@ func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsE } }() - var response []time.Time + var response uint8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixArray", + OperationName: "TestResponseIntegerUint8", OperationSummary: "", - OperationID: "test_response_integer_unix_array", + OperationID: "test_response_integer_uint8", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77186,7 +77195,7 @@ func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []time.Time + Response = uint8 ) response, err = middleware.HookMiddleware[ Request, @@ -77197,12 +77206,12 @@ func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8(ctx, request) } if err != nil { recordError("Internal", err) @@ -77210,7 +77219,7 @@ func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseIntegerUnixArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint8Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77219,18 +77228,18 @@ func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsE } } -// handleTestResponseIntegerUnixArrayArrayRequest handles test_response_integer_unix_array_array operation. +// handleTestResponseIntegerUint8ArrayRequest handles test_response_integer_uint8_array operation. // -// POST /test_response_integer_unix_array_array -func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint8_array +func (s *Server) handleTestResponseIntegerUint8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix_array_array"), + otelogen.OperationID("test_response_integer_uint8_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint8_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77255,11 +77264,11 @@ func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixArrayArray", - ID: "test_response_integer_unix_array_array", + Name: "TestResponseIntegerUint8Array", + ID: "test_response_integer_uint8_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint8ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77275,13 +77284,13 @@ func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, } }() - var response [][]time.Time + var response []uint8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixArrayArray", + OperationName: "TestResponseIntegerUint8Array", OperationSummary: "", - OperationID: "test_response_integer_unix_array_array", + OperationID: "test_response_integer_uint8_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77290,7 +77299,7 @@ func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]time.Time + Response = []uint8 ) response, err = middleware.HookMiddleware[ Request, @@ -77301,12 +77310,12 @@ func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -77314,7 +77323,7 @@ func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerUnixArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint8ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77323,18 +77332,18 @@ func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, } } -// handleTestResponseIntegerUnixMicroRequest handles test_response_integer_unix-micro operation. +// handleTestResponseIntegerUint8ArrayArrayRequest handles test_response_integer_uint8_array_array operation. // -// POST /test_response_integer_unix-micro -func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint8_array_array +func (s *Server) handleTestResponseIntegerUint8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-micro"), + otelogen.OperationID("test_response_integer_uint8_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-micro"), + semconv.HTTPRouteKey.String("/test_response_integer_uint8_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicro", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77359,11 +77368,11 @@ func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMicro", - ID: "test_response_integer_unix-micro", + Name: "TestResponseIntegerUint8ArrayArray", + ID: "test_response_integer_uint8_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMicroRequest(r) + request, close, err := s.decodeTestResponseIntegerUint8ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77379,13 +77388,13 @@ func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsE } }() - var response time.Time + var response [][]uint8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMicro", + OperationName: "TestResponseIntegerUint8ArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-micro", + OperationID: "test_response_integer_uint8_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77394,7 +77403,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = time.Time + Response = [][]uint8 ) response, err = middleware.HookMiddleware[ Request, @@ -77405,12 +77414,12 @@ func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMicro(ctx, request) + response, err = s.h.TestResponseIntegerUint8ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMicro(ctx, request) + response, err = s.h.TestResponseIntegerUint8ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -77418,7 +77427,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsE return } - if err := encodeTestResponseIntegerUnixMicroResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint8ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77427,18 +77436,18 @@ func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsE } } -// handleTestResponseIntegerUnixMicroArrayRequest handles test_response_integer_unix-micro_array operation. +// handleTestResponseIntegerUint8NullableRequest handles test_response_integer_uint8_nullable operation. // -// POST /test_response_integer_unix-micro_array -func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint8_nullable +func (s *Server) handleTestResponseIntegerUint8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-micro_array"), + otelogen.OperationID("test_response_integer_uint8_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint8_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77463,11 +77472,11 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMicroArray", - ID: "test_response_integer_unix-micro_array", + Name: "TestResponseIntegerUint8Nullable", + ID: "test_response_integer_uint8_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUnixMicroArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint8NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77483,13 +77492,13 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, } }() - var response []time.Time + var response NilUint8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMicroArray", + OperationName: "TestResponseIntegerUint8Nullable", OperationSummary: "", - OperationID: "test_response_integer_unix-micro_array", + OperationID: "test_response_integer_uint8_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77498,7 +77507,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = []time.Time + Response = NilUint8 ) response, err = middleware.HookMiddleware[ Request, @@ -77509,12 +77518,12 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMicroArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMicroArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -77522,7 +77531,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerUnixMicroArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint8NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77531,18 +77540,18 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, } } -// handleTestResponseIntegerUnixMicroArrayArrayRequest handles test_response_integer_unix-micro_array_array operation. +// handleTestResponseIntegerUint8NullableArrayRequest handles test_response_integer_uint8_nullable_array operation. // -// POST /test_response_integer_unix-micro_array_array -func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint8_nullable_array +func (s *Server) handleTestResponseIntegerUint8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-micro_array_array"), + otelogen.OperationID("test_response_integer_uint8_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint8_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77567,11 +77576,11 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMicroArrayArray", - ID: "test_response_integer_unix-micro_array_array", + Name: "TestResponseIntegerUint8NullableArray", + ID: "test_response_integer_uint8_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMicroArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUint8NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77587,13 +77596,13 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]str } }() - var response [][]time.Time + var response []NilUint8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMicroArrayArray", + OperationName: "TestResponseIntegerUint8NullableArray", OperationSummary: "", - OperationID: "test_response_integer_unix-micro_array_array", + OperationID: "test_response_integer_uint8_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77602,7 +77611,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = [][]time.Time + Response = []NilUint8 ) response, err = middleware.HookMiddleware[ Request, @@ -77613,12 +77622,12 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMicroArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMicroArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUint8NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -77626,7 +77635,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]str return } - if err := encodeTestResponseIntegerUnixMicroArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint8NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77635,18 +77644,18 @@ func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]str } } -// handleTestResponseIntegerUnixMicroNullableRequest handles test_response_integer_unix-micro_nullable operation. +// handleTestResponseIntegerUint8NullableArrayArrayRequest handles test_response_integer_uint8_nullable_array_array operation. // -// POST /test_response_integer_unix-micro_nullable -func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint8_nullable_array_array +func (s *Server) handleTestResponseIntegerUint8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-micro_nullable"), + otelogen.OperationID("test_response_integer_uint8_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_uint8_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUint8NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77671,11 +77680,11 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMicroNullable", - ID: "test_response_integer_unix-micro_nullable", + Name: "TestResponseIntegerUint8NullableArrayArray", + ID: "test_response_integer_uint8_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMicroNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUint8NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77691,13 +77700,13 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]strin } }() - var response NilUnixMicro + var response [][]NilUint8 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMicroNullable", + OperationName: "TestResponseIntegerUint8NullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-micro_nullable", + OperationID: "test_response_integer_uint8_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77706,7 +77715,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]strin type ( Request = string Params = struct{} - Response = NilUnixMicro + Response = [][]NilUint8 ) response, err = middleware.HookMiddleware[ Request, @@ -77717,12 +77726,12 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMicroNullable(ctx, request) + response, err = s.h.TestResponseIntegerUint8NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMicroNullable(ctx, request) + response, err = s.h.TestResponseIntegerUint8NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -77730,7 +77739,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]strin return } - if err := encodeTestResponseIntegerUnixMicroNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUint8NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77739,18 +77748,18 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]strin } } -// handleTestResponseIntegerUnixMicroNullableArrayRequest handles test_response_integer_unix-micro_nullable_array operation. +// handleTestResponseIntegerUintArrayRequest handles test_response_integer_uint_array operation. // -// POST /test_response_integer_unix-micro_nullable_array -func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_array +func (s *Server) handleTestResponseIntegerUintArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-micro_nullable_array"), + otelogen.OperationID("test_response_integer_uint_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77775,11 +77784,11 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMicroNullableArray", - ID: "test_response_integer_unix-micro_nullable_array", + Name: "TestResponseIntegerUintArray", + ID: "test_response_integer_uint_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMicroNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUintArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77795,13 +77804,13 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0] } }() - var response []NilUnixMicro + var response []uint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMicroNullableArray", + OperationName: "TestResponseIntegerUintArray", OperationSummary: "", - OperationID: "test_response_integer_unix-micro_nullable_array", + OperationID: "test_response_integer_uint_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77810,7 +77819,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0] type ( Request = string Params = struct{} - Response = []NilUnixMicro + Response = []uint ) response, err = middleware.HookMiddleware[ Request, @@ -77821,12 +77830,12 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMicroNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUintArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMicroNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUintArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -77834,7 +77843,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0] return } - if err := encodeTestResponseIntegerUnixMicroNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77843,18 +77852,18 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0] } } -// handleTestResponseIntegerUnixMicroNullableArrayArrayRequest handles test_response_integer_unix-micro_nullable_array_array operation. +// handleTestResponseIntegerUintArrayArrayRequest handles test_response_integer_uint_array_array operation. // -// POST /test_response_integer_unix-micro_nullable_array_array -func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_array_array +func (s *Server) handleTestResponseIntegerUintArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-micro_nullable_array_array"), + otelogen.OperationID("test_response_integer_uint_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77879,11 +77888,11 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMicroNullableArrayArray", - ID: "test_response_integer_unix-micro_nullable_array_array", + Name: "TestResponseIntegerUintArrayArray", + ID: "test_response_integer_uint_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMicroNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUintArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -77899,13 +77908,13 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(arg } }() - var response [][]NilUnixMicro + var response [][]uint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMicroNullableArrayArray", + OperationName: "TestResponseIntegerUintArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-micro_nullable_array_array", + OperationID: "test_response_integer_uint_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -77914,7 +77923,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(arg type ( Request = string Params = struct{} - Response = [][]NilUnixMicro + Response = [][]uint ) response, err = middleware.HookMiddleware[ Request, @@ -77925,12 +77934,12 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUintArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMicroNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUintArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -77938,7 +77947,7 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(arg return } - if err := encodeTestResponseIntegerUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -77947,18 +77956,18 @@ func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(arg } } -// handleTestResponseIntegerUnixMilliRequest handles test_response_integer_unix-milli operation. +// handleTestResponseIntegerUintNullableRequest handles test_response_integer_uint_nullable operation. // -// POST /test_response_integer_unix-milli -func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_nullable +func (s *Server) handleTestResponseIntegerUintNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-milli"), + otelogen.OperationID("test_response_integer_uint_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-milli"), + semconv.HTTPRouteKey.String("/test_response_integer_uint_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilli", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -77983,11 +77992,11 @@ func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMilli", - ID: "test_response_integer_unix-milli", + Name: "TestResponseIntegerUintNullable", + ID: "test_response_integer_uint_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUnixMilliRequest(r) + request, close, err := s.decodeTestResponseIntegerUintNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78003,13 +78012,13 @@ func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsE } }() - var response time.Time + var response NilUint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMilli", + OperationName: "TestResponseIntegerUintNullable", OperationSummary: "", - OperationID: "test_response_integer_unix-milli", + OperationID: "test_response_integer_uint_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78018,7 +78027,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = time.Time + Response = NilUint ) response, err = middleware.HookMiddleware[ Request, @@ -78029,12 +78038,12 @@ func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMilli(ctx, request) + response, err = s.h.TestResponseIntegerUintNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMilli(ctx, request) + response, err = s.h.TestResponseIntegerUintNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -78042,7 +78051,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsE return } - if err := encodeTestResponseIntegerUnixMilliResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78051,18 +78060,18 @@ func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsE } } -// handleTestResponseIntegerUnixMilliArrayRequest handles test_response_integer_unix-milli_array operation. +// handleTestResponseIntegerUintNullableArrayRequest handles test_response_integer_uint_nullable_array operation. // -// POST /test_response_integer_unix-milli_array -func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_nullable_array +func (s *Server) handleTestResponseIntegerUintNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-milli_array"), + otelogen.OperationID("test_response_integer_uint_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78087,11 +78096,11 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMilliArray", - ID: "test_response_integer_unix-milli_array", + Name: "TestResponseIntegerUintNullableArray", + ID: "test_response_integer_uint_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMilliArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUintNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78107,13 +78116,13 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, } }() - var response []time.Time + var response []NilUint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMilliArray", + OperationName: "TestResponseIntegerUintNullableArray", OperationSummary: "", - OperationID: "test_response_integer_unix-milli_array", + OperationID: "test_response_integer_uint_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78122,7 +78131,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = []time.Time + Response = []NilUint ) response, err = middleware.HookMiddleware[ Request, @@ -78133,12 +78142,12 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMilliArray(ctx, request) + response, err = s.h.TestResponseIntegerUintNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMilliArray(ctx, request) + response, err = s.h.TestResponseIntegerUintNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -78146,7 +78155,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, return } - if err := encodeTestResponseIntegerUnixMilliArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78155,18 +78164,18 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, } } -// handleTestResponseIntegerUnixMilliArrayArrayRequest handles test_response_integer_unix-milli_array_array operation. +// handleTestResponseIntegerUintNullableArrayArrayRequest handles test_response_integer_uint_nullable_array_array operation. // -// POST /test_response_integer_unix-milli_array_array -func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_uint_nullable_array_array +func (s *Server) handleTestResponseIntegerUintNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-milli_array_array"), + otelogen.OperationID("test_response_integer_uint_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_uint_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUintNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78191,11 +78200,11 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMilliArrayArray", - ID: "test_response_integer_unix-milli_array_array", + Name: "TestResponseIntegerUintNullableArrayArray", + ID: "test_response_integer_uint_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMilliArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUintNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78211,13 +78220,13 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]str } }() - var response [][]time.Time + var response [][]NilUint if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMilliArrayArray", + OperationName: "TestResponseIntegerUintNullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-milli_array_array", + OperationID: "test_response_integer_uint_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78226,7 +78235,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = [][]time.Time + Response = [][]NilUint ) response, err = middleware.HookMiddleware[ Request, @@ -78237,12 +78246,12 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMilliArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUintNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMilliArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUintNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -78250,7 +78259,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]str return } - if err := encodeTestResponseIntegerUnixMilliArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUintNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78259,18 +78268,18 @@ func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]str } } -// handleTestResponseIntegerUnixMilliNullableRequest handles test_response_integer_unix-milli_nullable operation. +// handleTestResponseIntegerUnixRequest handles test_response_integer_unix operation. // -// POST /test_response_integer_unix-milli_nullable -func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix +func (s *Server) handleTestResponseIntegerUnixRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-milli_nullable"), + otelogen.OperationID("test_response_integer_unix"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_unix"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnix", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78295,11 +78304,11 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMilliNullable", - ID: "test_response_integer_unix-milli_nullable", + Name: "TestResponseIntegerUnix", + ID: "test_response_integer_unix", } ) - request, close, err := s.decodeTestResponseIntegerUnixMilliNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78315,13 +78324,13 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]strin } }() - var response NilUnixMilli + var response time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMilliNullable", + OperationName: "TestResponseIntegerUnix", OperationSummary: "", - OperationID: "test_response_integer_unix-milli_nullable", + OperationID: "test_response_integer_unix", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78330,7 +78339,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]strin type ( Request = string Params = struct{} - Response = NilUnixMilli + Response = time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -78341,12 +78350,12 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMilliNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnix(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMilliNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnix(ctx, request) } if err != nil { recordError("Internal", err) @@ -78354,7 +78363,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]strin return } - if err := encodeTestResponseIntegerUnixMilliNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78363,18 +78372,18 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]strin } } -// handleTestResponseIntegerUnixMilliNullableArrayRequest handles test_response_integer_unix-milli_nullable_array operation. +// handleTestResponseIntegerUnixArrayRequest handles test_response_integer_unix_array operation. // -// POST /test_response_integer_unix-milli_nullable_array -func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix_array +func (s *Server) handleTestResponseIntegerUnixArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-milli_nullable_array"), + otelogen.OperationID("test_response_integer_unix_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78399,11 +78408,11 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMilliNullableArray", - ID: "test_response_integer_unix-milli_nullable_array", + Name: "TestResponseIntegerUnixArray", + ID: "test_response_integer_unix_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMilliNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78419,13 +78428,13 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0] } }() - var response []NilUnixMilli + var response []time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMilliNullableArray", + OperationName: "TestResponseIntegerUnixArray", OperationSummary: "", - OperationID: "test_response_integer_unix-milli_nullable_array", + OperationID: "test_response_integer_unix_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78434,7 +78443,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0] type ( Request = string Params = struct{} - Response = []NilUnixMilli + Response = []time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -78445,12 +78454,12 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMilliNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMilliNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -78458,7 +78467,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0] return } - if err := encodeTestResponseIntegerUnixMilliNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78467,18 +78476,18 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0] } } -// handleTestResponseIntegerUnixMilliNullableArrayArrayRequest handles test_response_integer_unix-milli_nullable_array_array operation. +// handleTestResponseIntegerUnixArrayArrayRequest handles test_response_integer_unix_array_array operation. // -// POST /test_response_integer_unix-milli_nullable_array_array -func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix_array_array +func (s *Server) handleTestResponseIntegerUnixArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-milli_nullable_array_array"), + otelogen.OperationID("test_response_integer_unix_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78503,11 +78512,11 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixMilliNullableArrayArray", - ID: "test_response_integer_unix-milli_nullable_array_array", + Name: "TestResponseIntegerUnixArrayArray", + ID: "test_response_integer_unix_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixMilliNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78523,13 +78532,13 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(arg } }() - var response [][]NilUnixMilli + var response [][]time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixMilliNullableArrayArray", + OperationName: "TestResponseIntegerUnixArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-milli_nullable_array_array", + OperationID: "test_response_integer_unix_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78538,7 +78547,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(arg type ( Request = string Params = struct{} - Response = [][]NilUnixMilli + Response = [][]time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -78549,12 +78558,12 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixMilliNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -78562,7 +78571,7 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(arg return } - if err := encodeTestResponseIntegerUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78571,18 +78580,18 @@ func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(arg } } -// handleTestResponseIntegerUnixNanoRequest handles test_response_integer_unix-nano operation. +// handleTestResponseIntegerUnixMicroRequest handles test_response_integer_unix-micro operation. // -// POST /test_response_integer_unix-nano -func (s *Server) handleTestResponseIntegerUnixNanoRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-micro +func (s *Server) handleTestResponseIntegerUnixMicroRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-nano"), + otelogen.OperationID("test_response_integer_unix-micro"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-nano"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-micro"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNano", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicro", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78607,11 +78616,11 @@ func (s *Server) handleTestResponseIntegerUnixNanoRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNano", - ID: "test_response_integer_unix-nano", + Name: "TestResponseIntegerUnixMicro", + ID: "test_response_integer_unix-micro", } ) - request, close, err := s.decodeTestResponseIntegerUnixNanoRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMicroRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78631,9 +78640,9 @@ func (s *Server) handleTestResponseIntegerUnixNanoRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNano", + OperationName: "TestResponseIntegerUnixMicro", OperationSummary: "", - OperationID: "test_response_integer_unix-nano", + OperationID: "test_response_integer_unix-micro", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78653,12 +78662,12 @@ func (s *Server) handleTestResponseIntegerUnixNanoRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNano(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicro(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNano(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicro(ctx, request) } if err != nil { recordError("Internal", err) @@ -78666,7 +78675,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoRequest(args [0]string, argsEs return } - if err := encodeTestResponseIntegerUnixNanoResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMicroResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78675,18 +78684,18 @@ func (s *Server) handleTestResponseIntegerUnixNanoRequest(args [0]string, argsEs } } -// handleTestResponseIntegerUnixNanoArrayRequest handles test_response_integer_unix-nano_array operation. +// handleTestResponseIntegerUnixMicroArrayRequest handles test_response_integer_unix-micro_array operation. // -// POST /test_response_integer_unix-nano_array -func (s *Server) handleTestResponseIntegerUnixNanoArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-micro_array +func (s *Server) handleTestResponseIntegerUnixMicroArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-nano_array"), + otelogen.OperationID("test_response_integer_unix-micro_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78711,11 +78720,11 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNanoArray", - ID: "test_response_integer_unix-nano_array", + Name: "TestResponseIntegerUnixMicroArray", + ID: "test_response_integer_unix-micro_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixNanoArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMicroArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78735,9 +78744,9 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNanoArray", + OperationName: "TestResponseIntegerUnixMicroArray", OperationSummary: "", - OperationID: "test_response_integer_unix-nano_array", + OperationID: "test_response_integer_unix-micro_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78757,12 +78766,12 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNanoArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNanoArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -78770,7 +78779,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayRequest(args [0]string, a return } - if err := encodeTestResponseIntegerUnixNanoArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMicroArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78779,18 +78788,18 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayRequest(args [0]string, a } } -// handleTestResponseIntegerUnixNanoArrayArrayRequest handles test_response_integer_unix-nano_array_array operation. +// handleTestResponseIntegerUnixMicroArrayArrayRequest handles test_response_integer_unix-micro_array_array operation. // -// POST /test_response_integer_unix-nano_array_array -func (s *Server) handleTestResponseIntegerUnixNanoArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-micro_array_array +func (s *Server) handleTestResponseIntegerUnixMicroArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-nano_array_array"), + otelogen.OperationID("test_response_integer_unix-micro_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78815,11 +78824,11 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNanoArrayArray", - ID: "test_response_integer_unix-nano_array_array", + Name: "TestResponseIntegerUnixMicroArrayArray", + ID: "test_response_integer_unix-micro_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixNanoArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMicroArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78839,9 +78848,9 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayArrayRequest(args [0]stri if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNanoArrayArray", + OperationName: "TestResponseIntegerUnixMicroArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-nano_array_array", + OperationID: "test_response_integer_unix-micro_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78861,12 +78870,12 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNanoArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNanoArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -78874,7 +78883,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayArrayRequest(args [0]stri return } - if err := encodeTestResponseIntegerUnixNanoArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMicroArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78883,18 +78892,18 @@ func (s *Server) handleTestResponseIntegerUnixNanoArrayArrayRequest(args [0]stri } } -// handleTestResponseIntegerUnixNanoNullableRequest handles test_response_integer_unix-nano_nullable operation. +// handleTestResponseIntegerUnixMicroNullableRequest handles test_response_integer_unix-micro_nullable operation. // -// POST /test_response_integer_unix-nano_nullable -func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-micro_nullable +func (s *Server) handleTestResponseIntegerUnixMicroNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-nano_nullable"), + otelogen.OperationID("test_response_integer_unix-micro_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -78919,11 +78928,11 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNanoNullable", - ID: "test_response_integer_unix-nano_nullable", + Name: "TestResponseIntegerUnixMicroNullable", + ID: "test_response_integer_unix-micro_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUnixNanoNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMicroNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -78939,13 +78948,13 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string } }() - var response NilUnixNano + var response NilUnixMicro if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNanoNullable", + OperationName: "TestResponseIntegerUnixMicroNullable", OperationSummary: "", - OperationID: "test_response_integer_unix-nano_nullable", + OperationID: "test_response_integer_unix-micro_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -78954,7 +78963,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string type ( Request = string Params = struct{} - Response = NilUnixNano + Response = NilUnixMicro ) response, err = middleware.HookMiddleware[ Request, @@ -78965,12 +78974,12 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNanoNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNanoNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -78978,7 +78987,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string return } - if err := encodeTestResponseIntegerUnixNanoNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMicroNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -78987,18 +78996,18 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string } } -// handleTestResponseIntegerUnixNanoNullableArrayRequest handles test_response_integer_unix-nano_nullable_array operation. +// handleTestResponseIntegerUnixMicroNullableArrayRequest handles test_response_integer_unix-micro_nullable_array operation. // -// POST /test_response_integer_unix-nano_nullable_array -func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-micro_nullable_array +func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-nano_nullable_array"), + otelogen.OperationID("test_response_integer_unix-micro_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79023,11 +79032,11 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNanoNullableArray", - ID: "test_response_integer_unix-nano_nullable_array", + Name: "TestResponseIntegerUnixMicroNullableArray", + ID: "test_response_integer_unix-micro_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixNanoNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMicroNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79043,13 +79052,13 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]s } }() - var response []NilUnixNano + var response []NilUnixMicro if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNanoNullableArray", + OperationName: "TestResponseIntegerUnixMicroNullableArray", OperationSummary: "", - OperationID: "test_response_integer_unix-nano_nullable_array", + OperationID: "test_response_integer_unix-micro_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79058,7 +79067,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]s type ( Request = string Params = struct{} - Response = []NilUnixNano + Response = []NilUnixMicro ) response, err = middleware.HookMiddleware[ Request, @@ -79069,12 +79078,12 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNanoNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNanoNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -79082,7 +79091,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]s return } - if err := encodeTestResponseIntegerUnixNanoNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMicroNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79091,18 +79100,18 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]s } } -// handleTestResponseIntegerUnixNanoNullableArrayArrayRequest handles test_response_integer_unix-nano_nullable_array_array operation. +// handleTestResponseIntegerUnixMicroNullableArrayArrayRequest handles test_response_integer_unix-micro_nullable_array_array operation. // -// POST /test_response_integer_unix-nano_nullable_array_array -func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-micro_nullable_array_array +func (s *Server) handleTestResponseIntegerUnixMicroNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-nano_nullable_array_array"), + otelogen.OperationID("test_response_integer_unix-micro_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-micro_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMicroNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79127,11 +79136,11 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNanoNullableArrayArray", - ID: "test_response_integer_unix-nano_nullable_array_array", + Name: "TestResponseIntegerUnixMicroNullableArrayArray", + ID: "test_response_integer_unix-micro_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixNanoNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMicroNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79147,13 +79156,13 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args } }() - var response [][]NilUnixNano + var response [][]NilUnixMicro if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNanoNullableArrayArray", + OperationName: "TestResponseIntegerUnixMicroNullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-nano_nullable_array_array", + OperationID: "test_response_integer_unix-micro_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79162,7 +79171,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args type ( Request = string Params = struct{} - Response = [][]NilUnixNano + Response = [][]NilUnixMicro ) response, err = middleware.HookMiddleware[ Request, @@ -79173,12 +79182,12 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNanoNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMicroNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -79186,7 +79195,7 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args return } - if err := encodeTestResponseIntegerUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMicroNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79195,18 +79204,18 @@ func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args } } -// handleTestResponseIntegerUnixNullableRequest handles test_response_integer_unix_nullable operation. +// handleTestResponseIntegerUnixMilliRequest handles test_response_integer_unix-milli operation. // -// POST /test_response_integer_unix_nullable -func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-milli +func (s *Server) handleTestResponseIntegerUnixMilliRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix_nullable"), + otelogen.OperationID("test_response_integer_unix-milli"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-milli"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilli", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79231,11 +79240,11 @@ func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNullable", - ID: "test_response_integer_unix_nullable", + Name: "TestResponseIntegerUnixMilli", + ID: "test_response_integer_unix-milli", } ) - request, close, err := s.decodeTestResponseIntegerUnixNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMilliRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79251,13 +79260,13 @@ func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, ar } }() - var response NilUnixSeconds + var response time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNullable", + OperationName: "TestResponseIntegerUnixMilli", OperationSummary: "", - OperationID: "test_response_integer_unix_nullable", + OperationID: "test_response_integer_unix-milli", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79266,7 +79275,7 @@ func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilUnixSeconds + Response = time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -79277,12 +79286,12 @@ func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilli(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilli(ctx, request) } if err != nil { recordError("Internal", err) @@ -79290,7 +79299,7 @@ func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, ar return } - if err := encodeTestResponseIntegerUnixNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMilliResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79299,18 +79308,18 @@ func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, ar } } -// handleTestResponseIntegerUnixNullableArrayRequest handles test_response_integer_unix_nullable_array operation. +// handleTestResponseIntegerUnixMilliArrayRequest handles test_response_integer_unix-milli_array operation. // -// POST /test_response_integer_unix_nullable_array -func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-milli_array +func (s *Server) handleTestResponseIntegerUnixMilliArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix_nullable_array"), + otelogen.OperationID("test_response_integer_unix-milli_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79335,11 +79344,11 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNullableArray", - ID: "test_response_integer_unix_nullable_array", + Name: "TestResponseIntegerUnixMilliArray", + ID: "test_response_integer_unix-milli_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMilliArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79355,13 +79364,13 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]strin } }() - var response []NilUnixSeconds + var response []time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNullableArray", + OperationName: "TestResponseIntegerUnixMilliArray", OperationSummary: "", - OperationID: "test_response_integer_unix_nullable_array", + OperationID: "test_response_integer_unix-milli_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79370,7 +79379,7 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilUnixSeconds + Response = []time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -79381,12 +79390,12 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -79394,7 +79403,7 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]strin return } - if err := encodeTestResponseIntegerUnixNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMilliArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79403,18 +79412,18 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]strin } } -// handleTestResponseIntegerUnixNullableArrayArrayRequest handles test_response_integer_unix_nullable_array_array operation. +// handleTestResponseIntegerUnixMilliArrayArrayRequest handles test_response_integer_unix-milli_array_array operation. // -// POST /test_response_integer_unix_nullable_array_array -func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-milli_array_array +func (s *Server) handleTestResponseIntegerUnixMilliArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix_nullable_array_array"), + otelogen.OperationID("test_response_integer_unix-milli_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79439,11 +79448,11 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixNullableArrayArray", - ID: "test_response_integer_unix_nullable_array_array", + Name: "TestResponseIntegerUnixMilliArrayArray", + ID: "test_response_integer_unix-milli_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMilliArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79459,13 +79468,13 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0] } }() - var response [][]NilUnixSeconds + var response [][]time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixNullableArrayArray", + OperationName: "TestResponseIntegerUnixMilliArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix_nullable_array_array", + OperationID: "test_response_integer_unix-milli_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79474,7 +79483,7 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilUnixSeconds + Response = [][]time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -79485,12 +79494,12 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -79498,7 +79507,7 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseIntegerUnixNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMilliArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79507,18 +79516,18 @@ func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0] } } -// handleTestResponseIntegerUnixSecondsRequest handles test_response_integer_unix-seconds operation. +// handleTestResponseIntegerUnixMilliNullableRequest handles test_response_integer_unix-milli_nullable operation. // -// POST /test_response_integer_unix-seconds -func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-milli_nullable +func (s *Server) handleTestResponseIntegerUnixMilliNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-seconds"), + otelogen.OperationID("test_response_integer_unix-milli_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSeconds", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79543,11 +79552,11 @@ func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixSeconds", - ID: "test_response_integer_unix-seconds", + Name: "TestResponseIntegerUnixMilliNullable", + ID: "test_response_integer_unix-milli_nullable", } ) - request, close, err := s.decodeTestResponseIntegerUnixSecondsRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMilliNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79563,13 +79572,13 @@ func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, arg } }() - var response time.Time + var response NilUnixMilli if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixSeconds", + OperationName: "TestResponseIntegerUnixMilliNullable", OperationSummary: "", - OperationID: "test_response_integer_unix-seconds", + OperationID: "test_response_integer_unix-milli_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79578,7 +79587,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = time.Time + Response = NilUnixMilli ) response, err = middleware.HookMiddleware[ Request, @@ -79589,12 +79598,12 @@ func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixSeconds(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixSeconds(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -79602,7 +79611,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, arg return } - if err := encodeTestResponseIntegerUnixSecondsResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMilliNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79611,18 +79620,18 @@ func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, arg } } -// handleTestResponseIntegerUnixSecondsArrayRequest handles test_response_integer_unix-seconds_array operation. +// handleTestResponseIntegerUnixMilliNullableArrayRequest handles test_response_integer_unix-milli_nullable_array operation. // -// POST /test_response_integer_unix-seconds_array -func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-milli_nullable_array +func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-seconds_array"), + otelogen.OperationID("test_response_integer_unix-milli_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79647,11 +79656,11 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixSecondsArray", - ID: "test_response_integer_unix-seconds_array", + Name: "TestResponseIntegerUnixMilliNullableArray", + ID: "test_response_integer_unix-milli_nullable_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixSecondsArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMilliNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79667,13 +79676,13 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string } }() - var response []time.Time + var response []NilUnixMilli if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixSecondsArray", + OperationName: "TestResponseIntegerUnixMilliNullableArray", OperationSummary: "", - OperationID: "test_response_integer_unix-seconds_array", + OperationID: "test_response_integer_unix-milli_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79682,7 +79691,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = []time.Time + Response = []NilUnixMilli ) response, err = middleware.HookMiddleware[ Request, @@ -79693,12 +79702,12 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixSecondsArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixSecondsArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -79706,7 +79715,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string return } - if err := encodeTestResponseIntegerUnixSecondsArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMilliNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79715,18 +79724,18 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string } } -// handleTestResponseIntegerUnixSecondsArrayArrayRequest handles test_response_integer_unix-seconds_array_array operation. +// handleTestResponseIntegerUnixMilliNullableArrayArrayRequest handles test_response_integer_unix-milli_nullable_array_array operation. // -// POST /test_response_integer_unix-seconds_array_array -func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-milli_nullable_array_array +func (s *Server) handleTestResponseIntegerUnixMilliNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-seconds_array_array"), + otelogen.OperationID("test_response_integer_unix-milli_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-milli_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixMilliNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79751,11 +79760,11 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixSecondsArrayArray", - ID: "test_response_integer_unix-seconds_array_array", + Name: "TestResponseIntegerUnixMilliNullableArrayArray", + ID: "test_response_integer_unix-milli_nullable_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixSecondsArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixMilliNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79771,13 +79780,13 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]s } }() - var response [][]time.Time + var response [][]NilUnixMilli if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixSecondsArrayArray", + OperationName: "TestResponseIntegerUnixMilliNullableArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-seconds_array_array", + OperationID: "test_response_integer_unix-milli_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79786,7 +79795,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]s type ( Request = string Params = struct{} - Response = [][]time.Time + Response = [][]NilUnixMilli ) response, err = middleware.HookMiddleware[ Request, @@ -79797,12 +79806,12 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixSecondsArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixMilliNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -79810,7 +79819,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]s return } - if err := encodeTestResponseIntegerUnixSecondsArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixMilliNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79819,18 +79828,18 @@ func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]s } } -// handleTestResponseIntegerUnixSecondsNullableRequest handles test_response_integer_unix-seconds_nullable operation. +// handleTestResponseIntegerUnixNanoRequest handles test_response_integer_unix-nano operation. // -// POST /test_response_integer_unix-seconds_nullable -func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-nano +func (s *Server) handleTestResponseIntegerUnixNanoRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-seconds_nullable"), + otelogen.OperationID("test_response_integer_unix-nano"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-nano"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNano", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79855,11 +79864,11 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixSecondsNullable", - ID: "test_response_integer_unix-seconds_nullable", + Name: "TestResponseIntegerUnixNano", + ID: "test_response_integer_unix-nano", } ) - request, close, err := s.decodeTestResponseIntegerUnixSecondsNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNanoRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79875,13 +79884,13 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]str } }() - var response NilUnixSeconds + var response time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixSecondsNullable", + OperationName: "TestResponseIntegerUnixNano", OperationSummary: "", - OperationID: "test_response_integer_unix-seconds_nullable", + OperationID: "test_response_integer_unix-nano", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79890,7 +79899,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]str type ( Request = string Params = struct{} - Response = NilUnixSeconds + Response = time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -79901,12 +79910,12 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixSecondsNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixNano(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixSecondsNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixNano(ctx, request) } if err != nil { recordError("Internal", err) @@ -79914,7 +79923,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]str return } - if err := encodeTestResponseIntegerUnixSecondsNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNanoResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -79923,18 +79932,18 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]str } } -// handleTestResponseIntegerUnixSecondsNullableArrayRequest handles test_response_integer_unix-seconds_nullable_array operation. +// handleTestResponseIntegerUnixNanoArrayRequest handles test_response_integer_unix-nano_array operation. // -// POST /test_response_integer_unix-seconds_nullable_array -func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-nano_array +func (s *Server) handleTestResponseIntegerUnixNanoArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-seconds_nullable_array"), + otelogen.OperationID("test_response_integer_unix-nano_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -79959,11 +79968,11 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixSecondsNullableArray", - ID: "test_response_integer_unix-seconds_nullable_array", + Name: "TestResponseIntegerUnixNanoArray", + ID: "test_response_integer_unix-nano_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixSecondsNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNanoArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -79979,13 +79988,13 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [ } }() - var response []NilUnixSeconds + var response []time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixSecondsNullableArray", + OperationName: "TestResponseIntegerUnixNanoArray", OperationSummary: "", - OperationID: "test_response_integer_unix-seconds_nullable_array", + OperationID: "test_response_integer_unix-nano_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -79994,7 +80003,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [ type ( Request = string Params = struct{} - Response = []NilUnixSeconds + Response = []time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -80005,12 +80014,12 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixSecondsNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -80018,7 +80027,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [ return } - if err := encodeTestResponseIntegerUnixSecondsNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNanoArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80027,18 +80036,18 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [ } } -// handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest handles test_response_integer_unix-seconds_nullable_array_array operation. +// handleTestResponseIntegerUnixNanoArrayArrayRequest handles test_response_integer_unix-nano_array_array operation. // -// POST /test_response_integer_unix-seconds_nullable_array_array -func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-nano_array_array +func (s *Server) handleTestResponseIntegerUnixNanoArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_integer_unix-seconds_nullable_array_array"), + otelogen.OperationID("test_response_integer_unix-nano_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80063,11 +80072,11 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseIntegerUnixSecondsNullableArrayArray", - ID: "test_response_integer_unix-seconds_nullable_array_array", + Name: "TestResponseIntegerUnixNanoArrayArray", + ID: "test_response_integer_unix-nano_array_array", } ) - request, close, err := s.decodeTestResponseIntegerUnixSecondsNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNanoArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80083,13 +80092,13 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(a } }() - var response [][]NilUnixSeconds + var response [][]time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseIntegerUnixSecondsNullableArrayArray", + OperationName: "TestResponseIntegerUnixNanoArrayArray", OperationSummary: "", - OperationID: "test_response_integer_unix-seconds_nullable_array_array", + OperationID: "test_response_integer_unix-nano_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80098,7 +80107,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(a type ( Request = string Params = struct{} - Response = [][]NilUnixSeconds + Response = [][]time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -80109,12 +80118,12 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseIntegerUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseIntegerUnixSecondsNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -80122,7 +80131,7 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(a return } - if err := encodeTestResponseIntegerUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNanoArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80131,18 +80140,18 @@ func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(a } } -// handleTestResponseNullRequest handles test_response_null operation. +// handleTestResponseIntegerUnixNanoNullableRequest handles test_response_integer_unix-nano_nullable operation. // -// POST /test_response_null -func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-nano_nullable +func (s *Server) handleTestResponseIntegerUnixNanoNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_null"), + otelogen.OperationID("test_response_integer_unix-nano_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_null"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNull", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80167,11 +80176,11 @@ func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNull", - ID: "test_response_null", + Name: "TestResponseIntegerUnixNanoNullable", + ID: "test_response_integer_unix-nano_nullable", } ) - request, close, err := s.decodeTestResponseNullRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNanoNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80187,13 +80196,13 @@ func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, } }() - var response struct{} + var response NilUnixNano if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNull", + OperationName: "TestResponseIntegerUnixNanoNullable", OperationSummary: "", - OperationID: "test_response_null", + OperationID: "test_response_integer_unix-nano_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80202,7 +80211,7 @@ func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, type ( Request = string Params = struct{} - Response = struct{} + Response = NilUnixNano ) response, err = middleware.HookMiddleware[ Request, @@ -80213,12 +80222,12 @@ func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNull(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNull(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -80226,7 +80235,7 @@ func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, return } - if err := encodeTestResponseNullResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNanoNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80235,18 +80244,18 @@ func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, } } -// handleTestResponseNullArrayRequest handles test_response_null_array operation. +// handleTestResponseIntegerUnixNanoNullableArrayRequest handles test_response_integer_unix-nano_nullable_array operation. // -// POST /test_response_null_array -func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-nano_nullable_array +func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_null_array"), + otelogen.OperationID("test_response_integer_unix-nano_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_null_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80271,11 +80280,11 @@ func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNullArray", - ID: "test_response_null_array", + Name: "TestResponseIntegerUnixNanoNullableArray", + ID: "test_response_integer_unix-nano_nullable_array", } ) - request, close, err := s.decodeTestResponseNullArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNanoNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80291,13 +80300,13 @@ func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped } }() - var response []struct{} + var response []NilUnixNano if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNullArray", + OperationName: "TestResponseIntegerUnixNanoNullableArray", OperationSummary: "", - OperationID: "test_response_null_array", + OperationID: "test_response_integer_unix-nano_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80306,7 +80315,7 @@ func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped type ( Request = string Params = struct{} - Response = []struct{} + Response = []NilUnixNano ) response, err = middleware.HookMiddleware[ Request, @@ -80317,12 +80326,12 @@ func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNullArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNullArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -80330,7 +80339,7 @@ func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped return } - if err := encodeTestResponseNullArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNanoNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80339,18 +80348,18 @@ func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped } } -// handleTestResponseNullArrayArrayRequest handles test_response_null_array_array operation. +// handleTestResponseIntegerUnixNanoNullableArrayArrayRequest handles test_response_integer_unix-nano_nullable_array_array operation. // -// POST /test_response_null_array_array -func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-nano_nullable_array_array +func (s *Server) handleTestResponseIntegerUnixNanoNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_null_array_array"), + otelogen.OperationID("test_response_integer_unix-nano_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_null_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-nano_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNanoNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80375,11 +80384,11 @@ func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNullArrayArray", - ID: "test_response_null_array_array", + Name: "TestResponseIntegerUnixNanoNullableArrayArray", + ID: "test_response_integer_unix-nano_nullable_array_array", } ) - request, close, err := s.decodeTestResponseNullArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNanoNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80395,13 +80404,13 @@ func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEsc } }() - var response [][]struct{} + var response [][]NilUnixNano if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNullArrayArray", + OperationName: "TestResponseIntegerUnixNanoNullableArrayArray", OperationSummary: "", - OperationID: "test_response_null_array_array", + OperationID: "test_response_integer_unix-nano_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80410,7 +80419,7 @@ func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEsc type ( Request = string Params = struct{} - Response = [][]struct{} + Response = [][]NilUnixNano ) response, err = middleware.HookMiddleware[ Request, @@ -80421,12 +80430,12 @@ func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNullArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNullArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNanoNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -80434,7 +80443,7 @@ func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEsc return } - if err := encodeTestResponseNullArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNanoNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80443,18 +80452,18 @@ func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEsc } } -// handleTestResponseNullNullableRequest handles test_response_null_nullable operation. +// handleTestResponseIntegerUnixNullableRequest handles test_response_integer_unix_nullable operation. // -// POST /test_response_null_nullable -func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix_nullable +func (s *Server) handleTestResponseIntegerUnixNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_null_nullable"), + otelogen.OperationID("test_response_integer_unix_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_null_nullable"), + semconv.HTTPRouteKey.String("/test_response_integer_unix_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80479,11 +80488,11 @@ func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNullNullable", - ID: "test_response_null_nullable", + Name: "TestResponseIntegerUnixNullable", + ID: "test_response_integer_unix_nullable", } ) - request, close, err := s.decodeTestResponseNullNullableRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80499,13 +80508,13 @@ func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscap } }() - var response struct{} + var response NilUnixSeconds if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNullNullable", + OperationName: "TestResponseIntegerUnixNullable", OperationSummary: "", - OperationID: "test_response_null_nullable", + OperationID: "test_response_integer_unix_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80514,7 +80523,7 @@ func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = struct{} + Response = NilUnixSeconds ) response, err = middleware.HookMiddleware[ Request, @@ -80525,12 +80534,12 @@ func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNullNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNullNullable(ctx, request) + response, err = s.h.TestResponseIntegerUnixNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -80538,7 +80547,7 @@ func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscap return } - if err := encodeTestResponseNullNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80547,18 +80556,18 @@ func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscap } } -// handleTestResponseNullNullableArrayRequest handles test_response_null_nullable_array operation. +// handleTestResponseIntegerUnixNullableArrayRequest handles test_response_integer_unix_nullable_array operation. // -// POST /test_response_null_nullable_array -func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix_nullable_array +func (s *Server) handleTestResponseIntegerUnixNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_null_nullable_array"), + otelogen.OperationID("test_response_integer_unix_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_null_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80583,11 +80592,11 @@ func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNullNullableArray", - ID: "test_response_null_nullable_array", + Name: "TestResponseIntegerUnixNullableArray", + ID: "test_response_integer_unix_nullable_array", } ) - request, close, err := s.decodeTestResponseNullNullableArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80603,13 +80612,13 @@ func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, args } }() - var response []struct{} + var response []NilUnixSeconds if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNullNullableArray", + OperationName: "TestResponseIntegerUnixNullableArray", OperationSummary: "", - OperationID: "test_response_null_nullable_array", + OperationID: "test_response_integer_unix_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80618,7 +80627,7 @@ func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = []struct{} + Response = []NilUnixSeconds ) response, err = middleware.HookMiddleware[ Request, @@ -80629,12 +80638,12 @@ func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNullNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNullNullableArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -80642,7 +80651,7 @@ func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, args return } - if err := encodeTestResponseNullNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80651,18 +80660,18 @@ func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, args } } -// handleTestResponseNullNullableArrayArrayRequest handles test_response_null_nullable_array_array operation. +// handleTestResponseIntegerUnixNullableArrayArrayRequest handles test_response_integer_unix_nullable_array_array operation. // -// POST /test_response_null_nullable_array_array -func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix_nullable_array_array +func (s *Server) handleTestResponseIntegerUnixNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_null_nullable_array_array"), + otelogen.OperationID("test_response_integer_unix_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_null_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80687,11 +80696,11 @@ func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNullNullableArrayArray", - ID: "test_response_null_nullable_array_array", + Name: "TestResponseIntegerUnixNullableArrayArray", + ID: "test_response_integer_unix_nullable_array_array", } ) - request, close, err := s.decodeTestResponseNullNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80707,13 +80716,13 @@ func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, } }() - var response [][]struct{} + var response [][]NilUnixSeconds if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNullNullableArrayArray", + OperationName: "TestResponseIntegerUnixNullableArrayArray", OperationSummary: "", - OperationID: "test_response_null_nullable_array_array", + OperationID: "test_response_integer_unix_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80722,7 +80731,7 @@ func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]struct{} + Response = [][]NilUnixSeconds ) response, err = middleware.HookMiddleware[ Request, @@ -80733,12 +80742,12 @@ func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNullNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNullNullableArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -80746,7 +80755,7 @@ func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseNullNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80755,18 +80764,18 @@ func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, } } -// handleTestResponseNumberRequest handles test_response_number operation. +// handleTestResponseIntegerUnixSecondsRequest handles test_response_integer_unix-seconds operation. // -// POST /test_response_number -func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-seconds +func (s *Server) handleTestResponseIntegerUnixSecondsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number"), + otelogen.OperationID("test_response_integer_unix-seconds"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumber", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSeconds", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80791,11 +80800,11 @@ func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped boo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumber", - ID: "test_response_number", + Name: "TestResponseIntegerUnixSeconds", + ID: "test_response_integer_unix-seconds", } ) - request, close, err := s.decodeTestResponseNumberRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixSecondsRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80811,13 +80820,13 @@ func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped boo } }() - var response float64 + var response time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumber", + OperationName: "TestResponseIntegerUnixSeconds", OperationSummary: "", - OperationID: "test_response_number", + OperationID: "test_response_integer_unix-seconds", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80826,7 +80835,7 @@ func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped boo type ( Request = string Params = struct{} - Response = float64 + Response = time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -80837,12 +80846,12 @@ func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped boo mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumber(ctx, request) + response, err = s.h.TestResponseIntegerUnixSeconds(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumber(ctx, request) + response, err = s.h.TestResponseIntegerUnixSeconds(ctx, request) } if err != nil { recordError("Internal", err) @@ -80850,7 +80859,7 @@ func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped boo return } - if err := encodeTestResponseNumberResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixSecondsResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80859,18 +80868,18 @@ func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped boo } } -// handleTestResponseNumberArrayRequest handles test_response_number_array operation. +// handleTestResponseIntegerUnixSecondsArrayRequest handles test_response_integer_unix-seconds_array operation. // -// POST /test_response_number_array -func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-seconds_array +func (s *Server) handleTestResponseIntegerUnixSecondsArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_array"), + otelogen.OperationID("test_response_integer_unix-seconds_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80895,11 +80904,11 @@ func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberArray", - ID: "test_response_number_array", + Name: "TestResponseIntegerUnixSecondsArray", + ID: "test_response_integer_unix-seconds_array", } ) - request, close, err := s.decodeTestResponseNumberArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixSecondsArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -80915,13 +80924,13 @@ func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscape } }() - var response []float64 + var response []time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberArray", + OperationName: "TestResponseIntegerUnixSecondsArray", OperationSummary: "", - OperationID: "test_response_number_array", + OperationID: "test_response_integer_unix-seconds_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -80930,7 +80939,7 @@ func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = []float64 + Response = []time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -80941,12 +80950,12 @@ func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -80954,7 +80963,7 @@ func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscape return } - if err := encodeTestResponseNumberArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixSecondsArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -80963,18 +80972,18 @@ func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscape } } -// handleTestResponseNumberArrayArrayRequest handles test_response_number_array_array operation. +// handleTestResponseIntegerUnixSecondsArrayArrayRequest handles test_response_integer_unix-seconds_array_array operation. // -// POST /test_response_number_array_array -func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-seconds_array_array +func (s *Server) handleTestResponseIntegerUnixSecondsArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_array_array"), + otelogen.OperationID("test_response_integer_unix-seconds_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -80999,11 +81008,11 @@ func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberArrayArray", - ID: "test_response_number_array_array", + Name: "TestResponseIntegerUnixSecondsArrayArray", + ID: "test_response_integer_unix-seconds_array_array", } ) - request, close, err := s.decodeTestResponseNumberArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixSecondsArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81019,13 +81028,13 @@ func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsE } }() - var response [][]float64 + var response [][]time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberArrayArray", + OperationName: "TestResponseIntegerUnixSecondsArrayArray", OperationSummary: "", - OperationID: "test_response_number_array_array", + OperationID: "test_response_integer_unix-seconds_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81034,7 +81043,7 @@ func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = [][]float64 + Response = [][]time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -81045,12 +81054,12 @@ func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -81058,7 +81067,7 @@ func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseNumberArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixSecondsArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81067,18 +81076,18 @@ func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsE } } -// handleTestResponseNumberDoubleRequest handles test_response_number_double operation. +// handleTestResponseIntegerUnixSecondsNullableRequest handles test_response_integer_unix-seconds_nullable operation. // -// POST /test_response_number_double -func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-seconds_nullable +func (s *Server) handleTestResponseIntegerUnixSecondsNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_double"), + otelogen.OperationID("test_response_integer_unix-seconds_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_double"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDouble", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81103,11 +81112,11 @@ func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberDouble", - ID: "test_response_number_double", + Name: "TestResponseIntegerUnixSecondsNullable", + ID: "test_response_integer_unix-seconds_nullable", } ) - request, close, err := s.decodeTestResponseNumberDoubleRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixSecondsNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81123,13 +81132,13 @@ func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscap } }() - var response float64 + var response NilUnixSeconds if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberDouble", + OperationName: "TestResponseIntegerUnixSecondsNullable", OperationSummary: "", - OperationID: "test_response_number_double", + OperationID: "test_response_integer_unix-seconds_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81138,7 +81147,7 @@ func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = float64 + Response = NilUnixSeconds ) response, err = middleware.HookMiddleware[ Request, @@ -81149,12 +81158,12 @@ func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberDouble(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberDouble(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -81162,7 +81171,7 @@ func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscap return } - if err := encodeTestResponseNumberDoubleResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixSecondsNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81171,18 +81180,18 @@ func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscap } } -// handleTestResponseNumberDoubleArrayRequest handles test_response_number_double_array operation. +// handleTestResponseIntegerUnixSecondsNullableArrayRequest handles test_response_integer_unix-seconds_nullable_array operation. // -// POST /test_response_number_double_array -func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-seconds_nullable_array +func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_double_array"), + otelogen.OperationID("test_response_integer_unix-seconds_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_double_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81207,11 +81216,11 @@ func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberDoubleArray", - ID: "test_response_number_double_array", + Name: "TestResponseIntegerUnixSecondsNullableArray", + ID: "test_response_integer_unix-seconds_nullable_array", } ) - request, close, err := s.decodeTestResponseNumberDoubleArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixSecondsNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81227,13 +81236,13 @@ func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, args } }() - var response []float64 + var response []NilUnixSeconds if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberDoubleArray", + OperationName: "TestResponseIntegerUnixSecondsNullableArray", OperationSummary: "", - OperationID: "test_response_number_double_array", + OperationID: "test_response_integer_unix-seconds_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81242,7 +81251,7 @@ func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = []float64 + Response = []NilUnixSeconds ) response, err = middleware.HookMiddleware[ Request, @@ -81253,12 +81262,12 @@ func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberDoubleArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberDoubleArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -81266,7 +81275,7 @@ func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, args return } - if err := encodeTestResponseNumberDoubleArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixSecondsNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81275,18 +81284,18 @@ func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, args } } -// handleTestResponseNumberDoubleArrayArrayRequest handles test_response_number_double_array_array operation. +// handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest handles test_response_integer_unix-seconds_nullable_array_array operation. // -// POST /test_response_number_double_array_array -func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_integer_unix-seconds_nullable_array_array +func (s *Server) handleTestResponseIntegerUnixSecondsNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_double_array_array"), + otelogen.OperationID("test_response_integer_unix-seconds_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_double_array_array"), + semconv.HTTPRouteKey.String("/test_response_integer_unix-seconds_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseIntegerUnixSecondsNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81311,11 +81320,11 @@ func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberDoubleArrayArray", - ID: "test_response_number_double_array_array", + Name: "TestResponseIntegerUnixSecondsNullableArrayArray", + ID: "test_response_integer_unix-seconds_nullable_array_array", } ) - request, close, err := s.decodeTestResponseNumberDoubleArrayArrayRequest(r) + request, close, err := s.decodeTestResponseIntegerUnixSecondsNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81331,13 +81340,13 @@ func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, } }() - var response [][]float64 + var response [][]NilUnixSeconds if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberDoubleArrayArray", + OperationName: "TestResponseIntegerUnixSecondsNullableArrayArray", OperationSummary: "", - OperationID: "test_response_number_double_array_array", + OperationID: "test_response_integer_unix-seconds_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81346,7 +81355,7 @@ func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]float64 + Response = [][]NilUnixSeconds ) response, err = middleware.HookMiddleware[ Request, @@ -81357,12 +81366,12 @@ func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberDoubleArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberDoubleArrayArray(ctx, request) + response, err = s.h.TestResponseIntegerUnixSecondsNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -81370,7 +81379,7 @@ func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseNumberDoubleArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseIntegerUnixSecondsNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81379,18 +81388,18 @@ func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, } } -// handleTestResponseNumberDoubleNullableRequest handles test_response_number_double_nullable operation. +// handleTestResponseNullRequest handles test_response_null operation. // -// POST /test_response_number_double_nullable -func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_null +func (s *Server) handleTestResponseNullRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_double_nullable"), + otelogen.OperationID("test_response_null"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_double_nullable"), + semconv.HTTPRouteKey.String("/test_response_null"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNull", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81415,11 +81424,11 @@ func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberDoubleNullable", - ID: "test_response_number_double_nullable", + Name: "TestResponseNull", + ID: "test_response_null", } ) - request, close, err := s.decodeTestResponseNumberDoubleNullableRequest(r) + request, close, err := s.decodeTestResponseNullRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81435,13 +81444,13 @@ func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, a } }() - var response NilFloat64 + var response struct{} if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberDoubleNullable", + OperationName: "TestResponseNull", OperationSummary: "", - OperationID: "test_response_number_double_nullable", + OperationID: "test_response_null", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81450,7 +81459,7 @@ func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, a type ( Request = string Params = struct{} - Response = NilFloat64 + Response = struct{} ) response, err = middleware.HookMiddleware[ Request, @@ -81461,12 +81470,12 @@ func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberDoubleNullable(ctx, request) + response, err = s.h.TestResponseNull(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberDoubleNullable(ctx, request) + response, err = s.h.TestResponseNull(ctx, request) } if err != nil { recordError("Internal", err) @@ -81474,7 +81483,7 @@ func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, a return } - if err := encodeTestResponseNumberDoubleNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseNullResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81483,18 +81492,18 @@ func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, a } } -// handleTestResponseNumberDoubleNullableArrayRequest handles test_response_number_double_nullable_array operation. +// handleTestResponseNullArrayRequest handles test_response_null_array operation. // -// POST /test_response_number_double_nullable_array -func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_null_array +func (s *Server) handleTestResponseNullArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_double_nullable_array"), + otelogen.OperationID("test_response_null_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_double_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_null_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81519,11 +81528,11 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberDoubleNullableArray", - ID: "test_response_number_double_nullable_array", + Name: "TestResponseNullArray", + ID: "test_response_null_array", } ) - request, close, err := s.decodeTestResponseNumberDoubleNullableArrayRequest(r) + request, close, err := s.decodeTestResponseNullArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81539,13 +81548,13 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]stri } }() - var response []NilFloat64 + var response []struct{} if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberDoubleNullableArray", + OperationName: "TestResponseNullArray", OperationSummary: "", - OperationID: "test_response_number_double_nullable_array", + OperationID: "test_response_null_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81554,7 +81563,7 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilFloat64 + Response = []struct{} ) response, err = middleware.HookMiddleware[ Request, @@ -81565,12 +81574,12 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberDoubleNullableArray(ctx, request) + response, err = s.h.TestResponseNullArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberDoubleNullableArray(ctx, request) + response, err = s.h.TestResponseNullArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -81578,7 +81587,7 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]stri return } - if err := encodeTestResponseNumberDoubleNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNullArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81587,18 +81596,18 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]stri } } -// handleTestResponseNumberDoubleNullableArrayArrayRequest handles test_response_number_double_nullable_array_array operation. +// handleTestResponseNullArrayArrayRequest handles test_response_null_array_array operation. // -// POST /test_response_number_double_nullable_array_array -func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_null_array_array +func (s *Server) handleTestResponseNullArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_double_nullable_array_array"), + otelogen.OperationID("test_response_null_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_double_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_null_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81623,11 +81632,11 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberDoubleNullableArrayArray", - ID: "test_response_number_double_nullable_array_array", + Name: "TestResponseNullArrayArray", + ID: "test_response_null_array_array", } ) - request, close, err := s.decodeTestResponseNumberDoubleNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNullArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81643,13 +81652,13 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0 } }() - var response [][]NilFloat64 + var response [][]struct{} if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberDoubleNullableArrayArray", + OperationName: "TestResponseNullArrayArray", OperationSummary: "", - OperationID: "test_response_number_double_nullable_array_array", + OperationID: "test_response_null_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81658,7 +81667,7 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilFloat64 + Response = [][]struct{} ) response, err = middleware.HookMiddleware[ Request, @@ -81669,12 +81678,12 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberDoubleNullableArrayArray(ctx, request) + response, err = s.h.TestResponseNullArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberDoubleNullableArrayArray(ctx, request) + response, err = s.h.TestResponseNullArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -81682,7 +81691,7 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseNumberDoubleNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNullArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81691,18 +81700,18 @@ func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0 } } -// handleTestResponseNumberFloatRequest handles test_response_number_float operation. +// handleTestResponseNullNullableRequest handles test_response_null_nullable operation. // -// POST /test_response_number_float -func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_null_nullable +func (s *Server) handleTestResponseNullNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_float"), + otelogen.OperationID("test_response_null_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_float"), + semconv.HTTPRouteKey.String("/test_response_null_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloat", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81727,11 +81736,11 @@ func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberFloat", - ID: "test_response_number_float", + Name: "TestResponseNullNullable", + ID: "test_response_null_nullable", } ) - request, close, err := s.decodeTestResponseNumberFloatRequest(r) + request, close, err := s.decodeTestResponseNullNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81747,13 +81756,13 @@ func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscape } }() - var response float32 + var response struct{} if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberFloat", + OperationName: "TestResponseNullNullable", OperationSummary: "", - OperationID: "test_response_number_float", + OperationID: "test_response_null_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81762,7 +81771,7 @@ func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = float32 + Response = struct{} ) response, err = middleware.HookMiddleware[ Request, @@ -81773,12 +81782,12 @@ func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberFloat(ctx, request) + response, err = s.h.TestResponseNullNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberFloat(ctx, request) + response, err = s.h.TestResponseNullNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -81786,7 +81795,7 @@ func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscape return } - if err := encodeTestResponseNumberFloatResponse(response, w, span); err != nil { + if err := encodeTestResponseNullNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81795,18 +81804,18 @@ func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscape } } -// handleTestResponseNumberFloatArrayRequest handles test_response_number_float_array operation. +// handleTestResponseNullNullableArrayRequest handles test_response_null_nullable_array operation. // -// POST /test_response_number_float_array -func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_null_nullable_array +func (s *Server) handleTestResponseNullNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_float_array"), + otelogen.OperationID("test_response_null_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_float_array"), + semconv.HTTPRouteKey.String("/test_response_null_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81831,11 +81840,11 @@ func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberFloatArray", - ID: "test_response_number_float_array", + Name: "TestResponseNullNullableArray", + ID: "test_response_null_nullable_array", } ) - request, close, err := s.decodeTestResponseNumberFloatArrayRequest(r) + request, close, err := s.decodeTestResponseNullNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81851,13 +81860,13 @@ func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsE } }() - var response []float32 + var response []struct{} if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberFloatArray", + OperationName: "TestResponseNullNullableArray", OperationSummary: "", - OperationID: "test_response_number_float_array", + OperationID: "test_response_null_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81866,7 +81875,7 @@ func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []float32 + Response = []struct{} ) response, err = middleware.HookMiddleware[ Request, @@ -81877,12 +81886,12 @@ func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberFloatArray(ctx, request) + response, err = s.h.TestResponseNullNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberFloatArray(ctx, request) + response, err = s.h.TestResponseNullNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -81890,7 +81899,7 @@ func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseNumberFloatArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNullNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -81899,18 +81908,18 @@ func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsE } } -// handleTestResponseNumberFloatArrayArrayRequest handles test_response_number_float_array_array operation. +// handleTestResponseNullNullableArrayArrayRequest handles test_response_null_nullable_array_array operation. // -// POST /test_response_number_float_array_array -func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_null_nullable_array_array +func (s *Server) handleTestResponseNullNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_float_array_array"), + otelogen.OperationID("test_response_null_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_float_array_array"), + semconv.HTTPRouteKey.String("/test_response_null_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNullNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -81935,11 +81944,11 @@ func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberFloatArrayArray", - ID: "test_response_number_float_array_array", + Name: "TestResponseNullNullableArrayArray", + ID: "test_response_null_nullable_array_array", } ) - request, close, err := s.decodeTestResponseNumberFloatArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNullNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -81955,13 +81964,13 @@ func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, } }() - var response [][]float32 + var response [][]struct{} if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberFloatArrayArray", + OperationName: "TestResponseNullNullableArrayArray", OperationSummary: "", - OperationID: "test_response_number_float_array_array", + OperationID: "test_response_null_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -81970,7 +81979,7 @@ func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]float32 + Response = [][]struct{} ) response, err = middleware.HookMiddleware[ Request, @@ -81981,12 +81990,12 @@ func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberFloatArrayArray(ctx, request) + response, err = s.h.TestResponseNullNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberFloatArrayArray(ctx, request) + response, err = s.h.TestResponseNullNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -81994,7 +82003,7 @@ func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseNumberFloatArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNullNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82003,18 +82012,18 @@ func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, } } -// handleTestResponseNumberFloatNullableRequest handles test_response_number_float_nullable operation. +// handleTestResponseNumberRequest handles test_response_number operation. // -// POST /test_response_number_float_nullable -func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number +func (s *Server) handleTestResponseNumberRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_float_nullable"), + otelogen.OperationID("test_response_number"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_float_nullable"), + semconv.HTTPRouteKey.String("/test_response_number"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumber", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82039,11 +82048,11 @@ func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberFloatNullable", - ID: "test_response_number_float_nullable", + Name: "TestResponseNumber", + ID: "test_response_number", } ) - request, close, err := s.decodeTestResponseNumberFloatNullableRequest(r) + request, close, err := s.decodeTestResponseNumberRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82059,13 +82068,13 @@ func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, ar } }() - var response NilFloat32 + var response float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberFloatNullable", + OperationName: "TestResponseNumber", OperationSummary: "", - OperationID: "test_response_number_float_nullable", + OperationID: "test_response_number", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82074,7 +82083,7 @@ func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilFloat32 + Response = float64 ) response, err = middleware.HookMiddleware[ Request, @@ -82085,12 +82094,12 @@ func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberFloatNullable(ctx, request) + response, err = s.h.TestResponseNumber(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberFloatNullable(ctx, request) + response, err = s.h.TestResponseNumber(ctx, request) } if err != nil { recordError("Internal", err) @@ -82098,7 +82107,7 @@ func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, ar return } - if err := encodeTestResponseNumberFloatNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82107,18 +82116,18 @@ func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, ar } } -// handleTestResponseNumberFloatNullableArrayRequest handles test_response_number_float_nullable_array operation. +// handleTestResponseNumberArrayRequest handles test_response_number_array operation. // -// POST /test_response_number_float_nullable_array -func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_array +func (s *Server) handleTestResponseNumberArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_float_nullable_array"), + otelogen.OperationID("test_response_number_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_float_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_number_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82143,11 +82152,11 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberFloatNullableArray", - ID: "test_response_number_float_nullable_array", + Name: "TestResponseNumberArray", + ID: "test_response_number_array", } ) - request, close, err := s.decodeTestResponseNumberFloatNullableArrayRequest(r) + request, close, err := s.decodeTestResponseNumberArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82163,13 +82172,13 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]strin } }() - var response []NilFloat32 + var response []float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberFloatNullableArray", + OperationName: "TestResponseNumberArray", OperationSummary: "", - OperationID: "test_response_number_float_nullable_array", + OperationID: "test_response_number_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82178,7 +82187,7 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilFloat32 + Response = []float64 ) response, err = middleware.HookMiddleware[ Request, @@ -82189,12 +82198,12 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberFloatNullableArray(ctx, request) + response, err = s.h.TestResponseNumberArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberFloatNullableArray(ctx, request) + response, err = s.h.TestResponseNumberArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -82202,7 +82211,7 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]strin return } - if err := encodeTestResponseNumberFloatNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82211,18 +82220,18 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]strin } } -// handleTestResponseNumberFloatNullableArrayArrayRequest handles test_response_number_float_nullable_array_array operation. +// handleTestResponseNumberArrayArrayRequest handles test_response_number_array_array operation. // -// POST /test_response_number_float_nullable_array_array -func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_array_array +func (s *Server) handleTestResponseNumberArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_float_nullable_array_array"), + otelogen.OperationID("test_response_number_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_float_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82247,11 +82256,11 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberFloatNullableArrayArray", - ID: "test_response_number_float_nullable_array_array", + Name: "TestResponseNumberArrayArray", + ID: "test_response_number_array_array", } ) - request, close, err := s.decodeTestResponseNumberFloatNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82267,13 +82276,13 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0] } }() - var response [][]NilFloat32 + var response [][]float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberFloatNullableArrayArray", + OperationName: "TestResponseNumberArrayArray", OperationSummary: "", - OperationID: "test_response_number_float_nullable_array_array", + OperationID: "test_response_number_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82282,7 +82291,7 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilFloat32 + Response = [][]float64 ) response, err = middleware.HookMiddleware[ Request, @@ -82293,12 +82302,12 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberFloatNullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberFloatNullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -82306,7 +82315,7 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseNumberFloatNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82315,18 +82324,18 @@ func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0] } } -// handleTestResponseNumberInt32Request handles test_response_number_int32 operation. +// handleTestResponseNumberDoubleRequest handles test_response_number_double operation. // -// POST /test_response_number_int32 -func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_double +func (s *Server) handleTestResponseNumberDoubleRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int32"), + otelogen.OperationID("test_response_number_double"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int32"), + semconv.HTTPRouteKey.String("/test_response_number_double"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDouble", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82351,11 +82360,11 @@ func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt32", - ID: "test_response_number_int32", + Name: "TestResponseNumberDouble", + ID: "test_response_number_double", } ) - request, close, err := s.decodeTestResponseNumberInt32Request(r) + request, close, err := s.decodeTestResponseNumberDoubleRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82371,13 +82380,13 @@ func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscape } }() - var response int32 + var response float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt32", + OperationName: "TestResponseNumberDouble", OperationSummary: "", - OperationID: "test_response_number_int32", + OperationID: "test_response_number_double", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82386,7 +82395,7 @@ func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = int32 + Response = float64 ) response, err = middleware.HookMiddleware[ Request, @@ -82397,12 +82406,12 @@ func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt32(ctx, request) + response, err = s.h.TestResponseNumberDouble(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt32(ctx, request) + response, err = s.h.TestResponseNumberDouble(ctx, request) } if err != nil { recordError("Internal", err) @@ -82410,7 +82419,7 @@ func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscape return } - if err := encodeTestResponseNumberInt32Response(response, w, span); err != nil { + if err := encodeTestResponseNumberDoubleResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82419,18 +82428,18 @@ func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscape } } -// handleTestResponseNumberInt32ArrayRequest handles test_response_number_int32_array operation. +// handleTestResponseNumberDoubleArrayRequest handles test_response_number_double_array operation. // -// POST /test_response_number_int32_array -func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_double_array +func (s *Server) handleTestResponseNumberDoubleArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int32_array"), + otelogen.OperationID("test_response_number_double_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int32_array"), + semconv.HTTPRouteKey.String("/test_response_number_double_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82455,11 +82464,11 @@ func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt32Array", - ID: "test_response_number_int32_array", + Name: "TestResponseNumberDoubleArray", + ID: "test_response_number_double_array", } ) - request, close, err := s.decodeTestResponseNumberInt32ArrayRequest(r) + request, close, err := s.decodeTestResponseNumberDoubleArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82475,13 +82484,13 @@ func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsE } }() - var response []int32 + var response []float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt32Array", + OperationName: "TestResponseNumberDoubleArray", OperationSummary: "", - OperationID: "test_response_number_int32_array", + OperationID: "test_response_number_double_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82490,7 +82499,7 @@ func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []int32 + Response = []float64 ) response, err = middleware.HookMiddleware[ Request, @@ -82501,12 +82510,12 @@ func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt32Array(ctx, request) + response, err = s.h.TestResponseNumberDoubleArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt32Array(ctx, request) + response, err = s.h.TestResponseNumberDoubleArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -82514,7 +82523,7 @@ func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseNumberInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberDoubleArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82523,18 +82532,18 @@ func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsE } } -// handleTestResponseNumberInt32ArrayArrayRequest handles test_response_number_int32_array_array operation. +// handleTestResponseNumberDoubleArrayArrayRequest handles test_response_number_double_array_array operation. // -// POST /test_response_number_int32_array_array -func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_double_array_array +func (s *Server) handleTestResponseNumberDoubleArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int32_array_array"), + otelogen.OperationID("test_response_number_double_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int32_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_double_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82559,11 +82568,11 @@ func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt32ArrayArray", - ID: "test_response_number_int32_array_array", + Name: "TestResponseNumberDoubleArrayArray", + ID: "test_response_number_double_array_array", } ) - request, close, err := s.decodeTestResponseNumberInt32ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberDoubleArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82579,13 +82588,13 @@ func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, } }() - var response [][]int32 + var response [][]float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt32ArrayArray", + OperationName: "TestResponseNumberDoubleArrayArray", OperationSummary: "", - OperationID: "test_response_number_int32_array_array", + OperationID: "test_response_number_double_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82594,7 +82603,7 @@ func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int32 + Response = [][]float64 ) response, err = middleware.HookMiddleware[ Request, @@ -82605,12 +82614,12 @@ func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt32ArrayArray(ctx, request) + response, err = s.h.TestResponseNumberDoubleArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt32ArrayArray(ctx, request) + response, err = s.h.TestResponseNumberDoubleArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -82618,7 +82627,7 @@ func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseNumberInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberDoubleArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82627,18 +82636,18 @@ func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, } } -// handleTestResponseNumberInt32NullableRequest handles test_response_number_int32_nullable operation. +// handleTestResponseNumberDoubleNullableRequest handles test_response_number_double_nullable operation. // -// POST /test_response_number_int32_nullable -func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_double_nullable +func (s *Server) handleTestResponseNumberDoubleNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int32_nullable"), + otelogen.OperationID("test_response_number_double_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int32_nullable"), + semconv.HTTPRouteKey.String("/test_response_number_double_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82663,11 +82672,11 @@ func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt32Nullable", - ID: "test_response_number_int32_nullable", + Name: "TestResponseNumberDoubleNullable", + ID: "test_response_number_double_nullable", } ) - request, close, err := s.decodeTestResponseNumberInt32NullableRequest(r) + request, close, err := s.decodeTestResponseNumberDoubleNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82683,13 +82692,13 @@ func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, ar } }() - var response NilInt32 + var response NilFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt32Nullable", + OperationName: "TestResponseNumberDoubleNullable", OperationSummary: "", - OperationID: "test_response_number_int32_nullable", + OperationID: "test_response_number_double_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82698,7 +82707,7 @@ func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilInt32 + Response = NilFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -82709,12 +82718,12 @@ func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt32Nullable(ctx, request) + response, err = s.h.TestResponseNumberDoubleNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt32Nullable(ctx, request) + response, err = s.h.TestResponseNumberDoubleNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -82722,7 +82731,7 @@ func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, ar return } - if err := encodeTestResponseNumberInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberDoubleNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82731,18 +82740,18 @@ func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, ar } } -// handleTestResponseNumberInt32NullableArrayRequest handles test_response_number_int32_nullable_array operation. +// handleTestResponseNumberDoubleNullableArrayRequest handles test_response_number_double_nullable_array operation. // -// POST /test_response_number_int32_nullable_array -func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_double_nullable_array +func (s *Server) handleTestResponseNumberDoubleNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int32_nullable_array"), + otelogen.OperationID("test_response_number_double_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int32_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_number_double_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82767,11 +82776,11 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt32NullableArray", - ID: "test_response_number_int32_nullable_array", + Name: "TestResponseNumberDoubleNullableArray", + ID: "test_response_number_double_nullable_array", } ) - request, close, err := s.decodeTestResponseNumberInt32NullableArrayRequest(r) + request, close, err := s.decodeTestResponseNumberDoubleNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82787,13 +82796,13 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]strin } }() - var response []NilInt32 + var response []NilFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt32NullableArray", + OperationName: "TestResponseNumberDoubleNullableArray", OperationSummary: "", - OperationID: "test_response_number_int32_nullable_array", + OperationID: "test_response_number_double_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82802,7 +82811,7 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilInt32 + Response = []NilFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -82813,12 +82822,12 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt32NullableArray(ctx, request) + response, err = s.h.TestResponseNumberDoubleNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt32NullableArray(ctx, request) + response, err = s.h.TestResponseNumberDoubleNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -82826,7 +82835,7 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]strin return } - if err := encodeTestResponseNumberInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberDoubleNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82835,18 +82844,18 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]strin } } -// handleTestResponseNumberInt32NullableArrayArrayRequest handles test_response_number_int32_nullable_array_array operation. +// handleTestResponseNumberDoubleNullableArrayArrayRequest handles test_response_number_double_nullable_array_array operation. // -// POST /test_response_number_int32_nullable_array_array -func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_double_nullable_array_array +func (s *Server) handleTestResponseNumberDoubleNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int32_nullable_array_array"), + otelogen.OperationID("test_response_number_double_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_double_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberDoubleNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82871,11 +82880,11 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt32NullableArrayArray", - ID: "test_response_number_int32_nullable_array_array", + Name: "TestResponseNumberDoubleNullableArrayArray", + ID: "test_response_number_double_nullable_array_array", } ) - request, close, err := s.decodeTestResponseNumberInt32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberDoubleNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82891,13 +82900,13 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0] } }() - var response [][]NilInt32 + var response [][]NilFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt32NullableArrayArray", + OperationName: "TestResponseNumberDoubleNullableArrayArray", OperationSummary: "", - OperationID: "test_response_number_int32_nullable_array_array", + OperationID: "test_response_number_double_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -82906,7 +82915,7 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilInt32 + Response = [][]NilFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -82917,12 +82926,12 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberDoubleNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberDoubleNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -82930,7 +82939,7 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseNumberInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberDoubleNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -82939,18 +82948,18 @@ func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0] } } -// handleTestResponseNumberInt64Request handles test_response_number_int64 operation. +// handleTestResponseNumberFloatRequest handles test_response_number_float operation. // -// POST /test_response_number_int64 -func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_float +func (s *Server) handleTestResponseNumberFloatRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int64"), + otelogen.OperationID("test_response_number_float"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int64"), + semconv.HTTPRouteKey.String("/test_response_number_float"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloat", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -82975,11 +82984,11 @@ func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt64", - ID: "test_response_number_int64", + Name: "TestResponseNumberFloat", + ID: "test_response_number_float", } ) - request, close, err := s.decodeTestResponseNumberInt64Request(r) + request, close, err := s.decodeTestResponseNumberFloatRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -82995,13 +83004,13 @@ func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscape } }() - var response int64 + var response float32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt64", + OperationName: "TestResponseNumberFloat", OperationSummary: "", - OperationID: "test_response_number_int64", + OperationID: "test_response_number_float", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83010,7 +83019,7 @@ func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = int64 + Response = float32 ) response, err = middleware.HookMiddleware[ Request, @@ -83021,12 +83030,12 @@ func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt64(ctx, request) + response, err = s.h.TestResponseNumberFloat(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt64(ctx, request) + response, err = s.h.TestResponseNumberFloat(ctx, request) } if err != nil { recordError("Internal", err) @@ -83034,7 +83043,7 @@ func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscape return } - if err := encodeTestResponseNumberInt64Response(response, w, span); err != nil { + if err := encodeTestResponseNumberFloatResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83043,18 +83052,18 @@ func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscape } } -// handleTestResponseNumberInt64ArrayRequest handles test_response_number_int64_array operation. +// handleTestResponseNumberFloatArrayRequest handles test_response_number_float_array operation. // -// POST /test_response_number_int64_array -func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_float_array +func (s *Server) handleTestResponseNumberFloatArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int64_array"), + otelogen.OperationID("test_response_number_float_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int64_array"), + semconv.HTTPRouteKey.String("/test_response_number_float_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83079,11 +83088,11 @@ func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt64Array", - ID: "test_response_number_int64_array", + Name: "TestResponseNumberFloatArray", + ID: "test_response_number_float_array", } ) - request, close, err := s.decodeTestResponseNumberInt64ArrayRequest(r) + request, close, err := s.decodeTestResponseNumberFloatArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83099,13 +83108,13 @@ func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsE } }() - var response []int64 + var response []float32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt64Array", + OperationName: "TestResponseNumberFloatArray", OperationSummary: "", - OperationID: "test_response_number_int64_array", + OperationID: "test_response_number_float_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83114,7 +83123,7 @@ func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []int64 + Response = []float32 ) response, err = middleware.HookMiddleware[ Request, @@ -83125,12 +83134,12 @@ func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt64Array(ctx, request) + response, err = s.h.TestResponseNumberFloatArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt64Array(ctx, request) + response, err = s.h.TestResponseNumberFloatArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -83138,7 +83147,7 @@ func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseNumberInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberFloatArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83147,18 +83156,18 @@ func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsE } } -// handleTestResponseNumberInt64ArrayArrayRequest handles test_response_number_int64_array_array operation. +// handleTestResponseNumberFloatArrayArrayRequest handles test_response_number_float_array_array operation. // -// POST /test_response_number_int64_array_array -func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_float_array_array +func (s *Server) handleTestResponseNumberFloatArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int64_array_array"), + otelogen.OperationID("test_response_number_float_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int64_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_float_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83183,11 +83192,11 @@ func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt64ArrayArray", - ID: "test_response_number_int64_array_array", + Name: "TestResponseNumberFloatArrayArray", + ID: "test_response_number_float_array_array", } ) - request, close, err := s.decodeTestResponseNumberInt64ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberFloatArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83203,13 +83212,13 @@ func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, } }() - var response [][]int64 + var response [][]float32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt64ArrayArray", + OperationName: "TestResponseNumberFloatArrayArray", OperationSummary: "", - OperationID: "test_response_number_int64_array_array", + OperationID: "test_response_number_float_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83218,7 +83227,7 @@ func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int64 + Response = [][]float32 ) response, err = middleware.HookMiddleware[ Request, @@ -83229,12 +83238,12 @@ func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt64ArrayArray(ctx, request) + response, err = s.h.TestResponseNumberFloatArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt64ArrayArray(ctx, request) + response, err = s.h.TestResponseNumberFloatArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -83242,7 +83251,7 @@ func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseNumberInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberFloatArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83251,18 +83260,18 @@ func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, } } -// handleTestResponseNumberInt64NullableRequest handles test_response_number_int64_nullable operation. +// handleTestResponseNumberFloatNullableRequest handles test_response_number_float_nullable operation. // -// POST /test_response_number_int64_nullable -func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_float_nullable +func (s *Server) handleTestResponseNumberFloatNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int64_nullable"), + otelogen.OperationID("test_response_number_float_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int64_nullable"), + semconv.HTTPRouteKey.String("/test_response_number_float_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83287,11 +83296,11 @@ func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt64Nullable", - ID: "test_response_number_int64_nullable", + Name: "TestResponseNumberFloatNullable", + ID: "test_response_number_float_nullable", } ) - request, close, err := s.decodeTestResponseNumberInt64NullableRequest(r) + request, close, err := s.decodeTestResponseNumberFloatNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83307,13 +83316,13 @@ func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, ar } }() - var response NilInt64 + var response NilFloat32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt64Nullable", + OperationName: "TestResponseNumberFloatNullable", OperationSummary: "", - OperationID: "test_response_number_int64_nullable", + OperationID: "test_response_number_float_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83322,7 +83331,7 @@ func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilInt64 + Response = NilFloat32 ) response, err = middleware.HookMiddleware[ Request, @@ -83333,12 +83342,12 @@ func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt64Nullable(ctx, request) + response, err = s.h.TestResponseNumberFloatNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt64Nullable(ctx, request) + response, err = s.h.TestResponseNumberFloatNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -83346,7 +83355,7 @@ func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, ar return } - if err := encodeTestResponseNumberInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberFloatNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83355,18 +83364,18 @@ func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, ar } } -// handleTestResponseNumberInt64NullableArrayRequest handles test_response_number_int64_nullable_array operation. +// handleTestResponseNumberFloatNullableArrayRequest handles test_response_number_float_nullable_array operation. // -// POST /test_response_number_int64_nullable_array -func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_float_nullable_array +func (s *Server) handleTestResponseNumberFloatNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int64_nullable_array"), + otelogen.OperationID("test_response_number_float_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int64_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_number_float_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83391,11 +83400,11 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt64NullableArray", - ID: "test_response_number_int64_nullable_array", + Name: "TestResponseNumberFloatNullableArray", + ID: "test_response_number_float_nullable_array", } ) - request, close, err := s.decodeTestResponseNumberInt64NullableArrayRequest(r) + request, close, err := s.decodeTestResponseNumberFloatNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83411,13 +83420,13 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]strin } }() - var response []NilInt64 + var response []NilFloat32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt64NullableArray", + OperationName: "TestResponseNumberFloatNullableArray", OperationSummary: "", - OperationID: "test_response_number_int64_nullable_array", + OperationID: "test_response_number_float_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83426,7 +83435,7 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilInt64 + Response = []NilFloat32 ) response, err = middleware.HookMiddleware[ Request, @@ -83437,12 +83446,12 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt64NullableArray(ctx, request) + response, err = s.h.TestResponseNumberFloatNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt64NullableArray(ctx, request) + response, err = s.h.TestResponseNumberFloatNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -83450,7 +83459,7 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]strin return } - if err := encodeTestResponseNumberInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberFloatNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83459,18 +83468,18 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]strin } } -// handleTestResponseNumberInt64NullableArrayArrayRequest handles test_response_number_int64_nullable_array_array operation. +// handleTestResponseNumberFloatNullableArrayArrayRequest handles test_response_number_float_nullable_array_array operation. // -// POST /test_response_number_int64_nullable_array_array -func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_float_nullable_array_array +func (s *Server) handleTestResponseNumberFloatNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_int64_nullable_array_array"), + otelogen.OperationID("test_response_number_float_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_int64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_float_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberFloatNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83495,11 +83504,11 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberInt64NullableArrayArray", - ID: "test_response_number_int64_nullable_array_array", + Name: "TestResponseNumberFloatNullableArrayArray", + ID: "test_response_number_float_nullable_array_array", } ) - request, close, err := s.decodeTestResponseNumberInt64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberFloatNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83515,13 +83524,13 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0] } }() - var response [][]NilInt64 + var response [][]NilFloat32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberInt64NullableArrayArray", + OperationName: "TestResponseNumberFloatNullableArrayArray", OperationSummary: "", - OperationID: "test_response_number_int64_nullable_array_array", + OperationID: "test_response_number_float_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83530,7 +83539,7 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilInt64 + Response = [][]NilFloat32 ) response, err = middleware.HookMiddleware[ Request, @@ -83541,12 +83550,12 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberInt64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberFloatNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberInt64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberFloatNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -83554,7 +83563,7 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseNumberInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberFloatNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83563,18 +83572,18 @@ func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0] } } -// handleTestResponseNumberNullableRequest handles test_response_number_nullable operation. +// handleTestResponseNumberInt32Request handles test_response_number_int32 operation. // -// POST /test_response_number_nullable -func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int32 +func (s *Server) handleTestResponseNumberInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_nullable"), + otelogen.OperationID("test_response_number_int32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_nullable"), + semconv.HTTPRouteKey.String("/test_response_number_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83599,11 +83608,11 @@ func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberNullable", - ID: "test_response_number_nullable", + Name: "TestResponseNumberInt32", + ID: "test_response_number_int32", } ) - request, close, err := s.decodeTestResponseNumberNullableRequest(r) + request, close, err := s.decodeTestResponseNumberInt32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83619,13 +83628,13 @@ func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEsc } }() - var response NilFloat64 + var response int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberNullable", + OperationName: "TestResponseNumberInt32", OperationSummary: "", - OperationID: "test_response_number_nullable", + OperationID: "test_response_number_int32", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83634,7 +83643,7 @@ func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEsc type ( Request = string Params = struct{} - Response = NilFloat64 + Response = int32 ) response, err = middleware.HookMiddleware[ Request, @@ -83645,12 +83654,12 @@ func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberNullable(ctx, request) + response, err = s.h.TestResponseNumberInt32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberNullable(ctx, request) + response, err = s.h.TestResponseNumberInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -83658,7 +83667,7 @@ func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEsc return } - if err := encodeTestResponseNumberNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83667,18 +83676,18 @@ func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEsc } } -// handleTestResponseNumberNullableArrayRequest handles test_response_number_nullable_array operation. +// handleTestResponseNumberInt32ArrayRequest handles test_response_number_int32_array operation. // -// POST /test_response_number_nullable_array -func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int32_array +func (s *Server) handleTestResponseNumberInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_nullable_array"), + otelogen.OperationID("test_response_number_int32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_number_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83703,11 +83712,11 @@ func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberNullableArray", - ID: "test_response_number_nullable_array", + Name: "TestResponseNumberInt32Array", + ID: "test_response_number_int32_array", } ) - request, close, err := s.decodeTestResponseNumberNullableArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83723,13 +83732,13 @@ func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, ar } }() - var response []NilFloat64 + var response []int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberNullableArray", + OperationName: "TestResponseNumberInt32Array", OperationSummary: "", - OperationID: "test_response_number_nullable_array", + OperationID: "test_response_number_int32_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83738,7 +83747,7 @@ func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = []NilFloat64 + Response = []int32 ) response, err = middleware.HookMiddleware[ Request, @@ -83749,12 +83758,12 @@ func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberNullableArray(ctx, request) + response, err = s.h.TestResponseNumberInt32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberNullableArray(ctx, request) + response, err = s.h.TestResponseNumberInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -83762,7 +83771,7 @@ func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, ar return } - if err := encodeTestResponseNumberNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83771,18 +83780,18 @@ func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, ar } } -// handleTestResponseNumberNullableArrayArrayRequest handles test_response_number_nullable_array_array operation. +// handleTestResponseNumberInt32ArrayArrayRequest handles test_response_number_int32_array_array operation. // -// POST /test_response_number_nullable_array_array -func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int32_array_array +func (s *Server) handleTestResponseNumberInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_number_nullable_array_array"), + otelogen.OperationID("test_response_number_int32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_number_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83807,11 +83816,11 @@ func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseNumberNullableArrayArray", - ID: "test_response_number_nullable_array_array", + Name: "TestResponseNumberInt32ArrayArray", + ID: "test_response_number_int32_array_array", } ) - request, close, err := s.decodeTestResponseNumberNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83827,13 +83836,13 @@ func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]strin } }() - var response [][]NilFloat64 + var response [][]int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseNumberNullableArrayArray", + OperationName: "TestResponseNumberInt32ArrayArray", OperationSummary: "", - OperationID: "test_response_number_nullable_array_array", + OperationID: "test_response_number_int32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83842,7 +83851,7 @@ func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = [][]NilFloat64 + Response = [][]int32 ) response, err = middleware.HookMiddleware[ Request, @@ -83853,12 +83862,12 @@ func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseNumberNullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseNumberNullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -83866,7 +83875,7 @@ func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]strin return } - if err := encodeTestResponseNumberNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83875,18 +83884,18 @@ func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]strin } } -// handleTestResponseStringRequest handles test_response_string operation. +// handleTestResponseNumberInt32NullableRequest handles test_response_number_int32_nullable operation. // -// POST /test_response_string -func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int32_nullable +func (s *Server) handleTestResponseNumberInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string"), + otelogen.OperationID("test_response_number_int32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string"), + semconv.HTTPRouteKey.String("/test_response_number_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseString", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -83911,11 +83920,11 @@ func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped boo } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseString", - ID: "test_response_string", + Name: "TestResponseNumberInt32Nullable", + ID: "test_response_number_int32_nullable", } ) - request, close, err := s.decodeTestResponseStringRequest(r) + request, close, err := s.decodeTestResponseNumberInt32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -83931,13 +83940,13 @@ func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped boo } }() - var response string + var response NilInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseString", + OperationName: "TestResponseNumberInt32Nullable", OperationSummary: "", - OperationID: "test_response_string", + OperationID: "test_response_number_int32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -83946,7 +83955,7 @@ func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped boo type ( Request = string Params = struct{} - Response = string + Response = NilInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -83957,12 +83966,12 @@ func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped boo mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseString(ctx, request) + response, err = s.h.TestResponseNumberInt32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseString(ctx, request) + response, err = s.h.TestResponseNumberInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -83970,7 +83979,7 @@ func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped boo return } - if err := encodeTestResponseStringResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -83979,18 +83988,18 @@ func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped boo } } -// handleTestResponseStringArrayRequest handles test_response_string_array operation. +// handleTestResponseNumberInt32NullableArrayRequest handles test_response_number_int32_nullable_array operation. // -// POST /test_response_string_array -func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int32_nullable_array +func (s *Server) handleTestResponseNumberInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_array"), + otelogen.OperationID("test_response_number_int32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_array"), + semconv.HTTPRouteKey.String("/test_response_number_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84015,11 +84024,11 @@ func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringArray", - ID: "test_response_string_array", + Name: "TestResponseNumberInt32NullableArray", + ID: "test_response_number_int32_nullable_array", } ) - request, close, err := s.decodeTestResponseStringArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84035,13 +84044,13 @@ func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscape } }() - var response []string + var response []NilInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringArray", + OperationName: "TestResponseNumberInt32NullableArray", OperationSummary: "", - OperationID: "test_response_string_array", + OperationID: "test_response_number_int32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84050,7 +84059,7 @@ func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = []string + Response = []NilInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -84061,12 +84070,12 @@ func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringArray(ctx, request) + response, err = s.h.TestResponseNumberInt32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringArray(ctx, request) + response, err = s.h.TestResponseNumberInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -84074,7 +84083,7 @@ func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscape return } - if err := encodeTestResponseStringArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84083,18 +84092,18 @@ func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscape } } -// handleTestResponseStringArrayArrayRequest handles test_response_string_array_array operation. +// handleTestResponseNumberInt32NullableArrayArrayRequest handles test_response_number_int32_nullable_array_array operation. // -// POST /test_response_string_array_array -func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int32_nullable_array_array +func (s *Server) handleTestResponseNumberInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_array_array"), + otelogen.OperationID("test_response_number_int32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84119,11 +84128,11 @@ func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringArrayArray", - ID: "test_response_string_array_array", + Name: "TestResponseNumberInt32NullableArrayArray", + ID: "test_response_number_int32_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84139,13 +84148,13 @@ func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsE } }() - var response [][]string + var response [][]NilInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringArrayArray", + OperationName: "TestResponseNumberInt32NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_array_array", + OperationID: "test_response_number_int32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84154,7 +84163,7 @@ func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = [][]string + Response = [][]NilInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -84165,12 +84174,12 @@ func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -84178,7 +84187,7 @@ func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseStringArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84187,18 +84196,18 @@ func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsE } } -// handleTestResponseStringBase64Request handles test_response_string_base64 operation. +// handleTestResponseNumberInt64Request handles test_response_number_int64 operation. // -// POST /test_response_string_base64 -func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int64 +func (s *Server) handleTestResponseNumberInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_base64"), + otelogen.OperationID("test_response_number_int64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_base64"), + semconv.HTTPRouteKey.String("/test_response_number_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84223,11 +84232,11 @@ func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBase64", - ID: "test_response_string_base64", + Name: "TestResponseNumberInt64", + ID: "test_response_number_int64", } ) - request, close, err := s.decodeTestResponseStringBase64Request(r) + request, close, err := s.decodeTestResponseNumberInt64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84243,13 +84252,13 @@ func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscap } }() - var response []byte + var response int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBase64", + OperationName: "TestResponseNumberInt64", OperationSummary: "", - OperationID: "test_response_string_base64", + OperationID: "test_response_number_int64", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84258,7 +84267,7 @@ func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = []byte + Response = int64 ) response, err = middleware.HookMiddleware[ Request, @@ -84269,12 +84278,12 @@ func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBase64(ctx, request) + response, err = s.h.TestResponseNumberInt64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBase64(ctx, request) + response, err = s.h.TestResponseNumberInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -84282,7 +84291,7 @@ func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscap return } - if err := encodeTestResponseStringBase64Response(response, w, span); err != nil { + if err := encodeTestResponseNumberInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84291,18 +84300,18 @@ func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscap } } -// handleTestResponseStringBase64ArrayRequest handles test_response_string_base64_array operation. +// handleTestResponseNumberInt64ArrayRequest handles test_response_number_int64_array operation. // -// POST /test_response_string_base64_array -func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int64_array +func (s *Server) handleTestResponseNumberInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_base64_array"), + otelogen.OperationID("test_response_number_int64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_base64_array"), + semconv.HTTPRouteKey.String("/test_response_number_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84327,11 +84336,11 @@ func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBase64Array", - ID: "test_response_string_base64_array", + Name: "TestResponseNumberInt64Array", + ID: "test_response_number_int64_array", } ) - request, close, err := s.decodeTestResponseStringBase64ArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84347,13 +84356,13 @@ func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, args } }() - var response [][]byte + var response []int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBase64Array", + OperationName: "TestResponseNumberInt64Array", OperationSummary: "", - OperationID: "test_response_string_base64_array", + OperationID: "test_response_number_int64_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84362,7 +84371,7 @@ func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = [][]byte + Response = []int64 ) response, err = middleware.HookMiddleware[ Request, @@ -84373,12 +84382,12 @@ func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBase64Array(ctx, request) + response, err = s.h.TestResponseNumberInt64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBase64Array(ctx, request) + response, err = s.h.TestResponseNumberInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -84386,7 +84395,7 @@ func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, args return } - if err := encodeTestResponseStringBase64ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84395,18 +84404,18 @@ func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, args } } -// handleTestResponseStringBase64ArrayArrayRequest handles test_response_string_base64_array_array operation. +// handleTestResponseNumberInt64ArrayArrayRequest handles test_response_number_int64_array_array operation. // -// POST /test_response_string_base64_array_array -func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int64_array_array +func (s *Server) handleTestResponseNumberInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_base64_array_array"), + otelogen.OperationID("test_response_number_int64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_base64_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84431,11 +84440,11 @@ func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBase64ArrayArray", - ID: "test_response_string_base64_array_array", + Name: "TestResponseNumberInt64ArrayArray", + ID: "test_response_number_int64_array_array", } ) - request, close, err := s.decodeTestResponseStringBase64ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84451,13 +84460,13 @@ func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, } }() - var response [][][]byte + var response [][]int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBase64ArrayArray", + OperationName: "TestResponseNumberInt64ArrayArray", OperationSummary: "", - OperationID: "test_response_string_base64_array_array", + OperationID: "test_response_number_int64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84466,7 +84475,7 @@ func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][][]byte + Response = [][]int64 ) response, err = middleware.HookMiddleware[ Request, @@ -84477,12 +84486,12 @@ func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBase64ArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBase64ArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -84490,7 +84499,7 @@ func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseStringBase64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84499,18 +84508,18 @@ func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, } } -// handleTestResponseStringBase64NullableRequest handles test_response_string_base64_nullable operation. +// handleTestResponseNumberInt64NullableRequest handles test_response_number_int64_nullable operation. // -// POST /test_response_string_base64_nullable -func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int64_nullable +func (s *Server) handleTestResponseNumberInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_base64_nullable"), + otelogen.OperationID("test_response_number_int64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_base64_nullable"), + semconv.HTTPRouteKey.String("/test_response_number_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84535,11 +84544,11 @@ func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBase64Nullable", - ID: "test_response_string_base64_nullable", + Name: "TestResponseNumberInt64Nullable", + ID: "test_response_number_int64_nullable", } ) - request, close, err := s.decodeTestResponseStringBase64NullableRequest(r) + request, close, err := s.decodeTestResponseNumberInt64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84555,13 +84564,13 @@ func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, a } }() - var response []byte + var response NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBase64Nullable", + OperationName: "TestResponseNumberInt64Nullable", OperationSummary: "", - OperationID: "test_response_string_base64_nullable", + OperationID: "test_response_number_int64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84570,7 +84579,7 @@ func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, a type ( Request = string Params = struct{} - Response = []byte + Response = NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -84581,12 +84590,12 @@ func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBase64Nullable(ctx, request) + response, err = s.h.TestResponseNumberInt64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBase64Nullable(ctx, request) + response, err = s.h.TestResponseNumberInt64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -84594,7 +84603,7 @@ func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, a return } - if err := encodeTestResponseStringBase64NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84603,18 +84612,18 @@ func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, a } } -// handleTestResponseStringBase64NullableArrayRequest handles test_response_string_base64_nullable_array operation. +// handleTestResponseNumberInt64NullableArrayRequest handles test_response_number_int64_nullable_array operation. // -// POST /test_response_string_base64_nullable_array -func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int64_nullable_array +func (s *Server) handleTestResponseNumberInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_base64_nullable_array"), + otelogen.OperationID("test_response_number_int64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_base64_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_number_int64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84639,11 +84648,11 @@ func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBase64NullableArray", - ID: "test_response_string_base64_nullable_array", + Name: "TestResponseNumberInt64NullableArray", + ID: "test_response_number_int64_nullable_array", } ) - request, close, err := s.decodeTestResponseStringBase64NullableArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84659,13 +84668,13 @@ func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]stri } }() - var response [][]byte + var response []NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBase64NullableArray", + OperationName: "TestResponseNumberInt64NullableArray", OperationSummary: "", - OperationID: "test_response_string_base64_nullable_array", + OperationID: "test_response_number_int64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84674,7 +84683,7 @@ func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = [][]byte + Response = []NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -84685,12 +84694,12 @@ func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBase64NullableArray(ctx, request) + response, err = s.h.TestResponseNumberInt64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBase64NullableArray(ctx, request) + response, err = s.h.TestResponseNumberInt64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -84698,7 +84707,7 @@ func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]stri return } - if err := encodeTestResponseStringBase64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84707,18 +84716,18 @@ func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]stri } } -// handleTestResponseStringBase64NullableArrayArrayRequest handles test_response_string_base64_nullable_array_array operation. +// handleTestResponseNumberInt64NullableArrayArrayRequest handles test_response_number_int64_nullable_array_array operation. // -// POST /test_response_string_base64_nullable_array_array -func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_int64_nullable_array_array +func (s *Server) handleTestResponseNumberInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_base64_nullable_array_array"), + otelogen.OperationID("test_response_number_int64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_base64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_int64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberInt64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84743,11 +84752,11 @@ func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBase64NullableArrayArray", - ID: "test_response_string_base64_nullable_array_array", + Name: "TestResponseNumberInt64NullableArrayArray", + ID: "test_response_number_int64_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringBase64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberInt64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84763,13 +84772,13 @@ func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0 } }() - var response [][][]byte + var response [][]NilInt64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBase64NullableArrayArray", + OperationName: "TestResponseNumberInt64NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_base64_nullable_array_array", + OperationID: "test_response_number_int64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84778,7 +84787,7 @@ func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][][]byte + Response = [][]NilInt64 ) response, err = middleware.HookMiddleware[ Request, @@ -84789,12 +84798,12 @@ func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBase64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBase64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseNumberInt64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -84802,7 +84811,7 @@ func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseStringBase64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberInt64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84811,18 +84820,18 @@ func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0 } } -// handleTestResponseStringBinaryRequest handles test_response_string_binary operation. +// handleTestResponseNumberNullableRequest handles test_response_number_nullable operation. // -// POST /test_response_string_binary -func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_nullable +func (s *Server) handleTestResponseNumberNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_binary"), + otelogen.OperationID("test_response_number_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_binary"), + semconv.HTTPRouteKey.String("/test_response_number_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinary", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84847,11 +84856,11 @@ func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscap } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBinary", - ID: "test_response_string_binary", + Name: "TestResponseNumberNullable", + ID: "test_response_number_nullable", } ) - request, close, err := s.decodeTestResponseStringBinaryRequest(r) + request, close, err := s.decodeTestResponseNumberNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84867,13 +84876,13 @@ func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscap } }() - var response string + var response NilFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBinary", + OperationName: "TestResponseNumberNullable", OperationSummary: "", - OperationID: "test_response_string_binary", + OperationID: "test_response_number_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84882,7 +84891,7 @@ func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscap type ( Request = string Params = struct{} - Response = string + Response = NilFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -84893,12 +84902,12 @@ func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscap mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBinary(ctx, request) + response, err = s.h.TestResponseNumberNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBinary(ctx, request) + response, err = s.h.TestResponseNumberNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -84906,7 +84915,7 @@ func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscap return } - if err := encodeTestResponseStringBinaryResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -84915,18 +84924,18 @@ func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscap } } -// handleTestResponseStringBinaryArrayRequest handles test_response_string_binary_array operation. +// handleTestResponseNumberNullableArrayRequest handles test_response_number_nullable_array operation. // -// POST /test_response_string_binary_array -func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_nullable_array +func (s *Server) handleTestResponseNumberNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_binary_array"), + otelogen.OperationID("test_response_number_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_binary_array"), + semconv.HTTPRouteKey.String("/test_response_number_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -84951,11 +84960,11 @@ func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBinaryArray", - ID: "test_response_string_binary_array", + Name: "TestResponseNumberNullableArray", + ID: "test_response_number_nullable_array", } ) - request, close, err := s.decodeTestResponseStringBinaryArrayRequest(r) + request, close, err := s.decodeTestResponseNumberNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -84971,13 +84980,13 @@ func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, args } }() - var response []string + var response []NilFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBinaryArray", + OperationName: "TestResponseNumberNullableArray", OperationSummary: "", - OperationID: "test_response_string_binary_array", + OperationID: "test_response_number_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -84986,7 +84995,7 @@ func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, args type ( Request = string Params = struct{} - Response = []string + Response = []NilFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -84997,12 +85006,12 @@ func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBinaryArray(ctx, request) + response, err = s.h.TestResponseNumberNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBinaryArray(ctx, request) + response, err = s.h.TestResponseNumberNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -85010,7 +85019,7 @@ func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, args return } - if err := encodeTestResponseStringBinaryArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85019,18 +85028,18 @@ func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, args } } -// handleTestResponseStringBinaryArrayArrayRequest handles test_response_string_binary_array_array operation. +// handleTestResponseNumberNullableArrayArrayRequest handles test_response_number_nullable_array_array operation. // -// POST /test_response_string_binary_array_array -func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_number_nullable_array_array +func (s *Server) handleTestResponseNumberNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_binary_array_array"), + otelogen.OperationID("test_response_number_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_binary_array_array"), + semconv.HTTPRouteKey.String("/test_response_number_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseNumberNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85055,11 +85064,11 @@ func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBinaryArrayArray", - ID: "test_response_string_binary_array_array", + Name: "TestResponseNumberNullableArrayArray", + ID: "test_response_number_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringBinaryArrayArrayRequest(r) + request, close, err := s.decodeTestResponseNumberNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85075,13 +85084,13 @@ func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, } }() - var response [][]string + var response [][]NilFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBinaryArrayArray", + OperationName: "TestResponseNumberNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_binary_array_array", + OperationID: "test_response_number_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85090,7 +85099,7 @@ func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]string + Response = [][]NilFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -85101,12 +85110,12 @@ func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBinaryArrayArray(ctx, request) + response, err = s.h.TestResponseNumberNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBinaryArrayArray(ctx, request) + response, err = s.h.TestResponseNumberNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -85114,7 +85123,7 @@ func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseStringBinaryArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseNumberNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85123,18 +85132,18 @@ func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, } } -// handleTestResponseStringBinaryNullableRequest handles test_response_string_binary_nullable operation. +// handleTestResponseStringRequest handles test_response_string operation. // -// POST /test_response_string_binary_nullable -func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string +func (s *Server) handleTestResponseStringRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_binary_nullable"), + otelogen.OperationID("test_response_string"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_binary_nullable"), + semconv.HTTPRouteKey.String("/test_response_string"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseString", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85159,11 +85168,11 @@ func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBinaryNullable", - ID: "test_response_string_binary_nullable", + Name: "TestResponseString", + ID: "test_response_string", } ) - request, close, err := s.decodeTestResponseStringBinaryNullableRequest(r) + request, close, err := s.decodeTestResponseStringRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85179,13 +85188,13 @@ func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, a } }() - var response NilString + var response string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBinaryNullable", + OperationName: "TestResponseString", OperationSummary: "", - OperationID: "test_response_string_binary_nullable", + OperationID: "test_response_string", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85194,7 +85203,7 @@ func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, a type ( Request = string Params = struct{} - Response = NilString + Response = string ) response, err = middleware.HookMiddleware[ Request, @@ -85205,12 +85214,12 @@ func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBinaryNullable(ctx, request) + response, err = s.h.TestResponseString(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBinaryNullable(ctx, request) + response, err = s.h.TestResponseString(ctx, request) } if err != nil { recordError("Internal", err) @@ -85218,7 +85227,7 @@ func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, a return } - if err := encodeTestResponseStringBinaryNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85227,18 +85236,18 @@ func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, a } } -// handleTestResponseStringBinaryNullableArrayRequest handles test_response_string_binary_nullable_array operation. +// handleTestResponseStringArrayRequest handles test_response_string_array operation. // -// POST /test_response_string_binary_nullable_array -func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_array +func (s *Server) handleTestResponseStringArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_binary_nullable_array"), + otelogen.OperationID("test_response_string_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_binary_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85263,11 +85272,11 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]stri } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBinaryNullableArray", - ID: "test_response_string_binary_nullable_array", + Name: "TestResponseStringArray", + ID: "test_response_string_array", } ) - request, close, err := s.decodeTestResponseStringBinaryNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85283,13 +85292,13 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]stri } }() - var response []NilString + var response []string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBinaryNullableArray", + OperationName: "TestResponseStringArray", OperationSummary: "", - OperationID: "test_response_string_binary_nullable_array", + OperationID: "test_response_string_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85298,7 +85307,7 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]stri type ( Request = string Params = struct{} - Response = []NilString + Response = []string ) response, err = middleware.HookMiddleware[ Request, @@ -85309,12 +85318,12 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]stri mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBinaryNullableArray(ctx, request) + response, err = s.h.TestResponseStringArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBinaryNullableArray(ctx, request) + response, err = s.h.TestResponseStringArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -85322,7 +85331,7 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]stri return } - if err := encodeTestResponseStringBinaryNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85331,18 +85340,18 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]stri } } -// handleTestResponseStringBinaryNullableArrayArrayRequest handles test_response_string_binary_nullable_array_array operation. +// handleTestResponseStringArrayArrayRequest handles test_response_string_array_array operation. // -// POST /test_response_string_binary_nullable_array_array -func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_array_array +func (s *Server) handleTestResponseStringArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_binary_nullable_array_array"), + otelogen.OperationID("test_response_string_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_binary_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85367,11 +85376,11 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0 } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringBinaryNullableArrayArray", - ID: "test_response_string_binary_nullable_array_array", + Name: "TestResponseStringArrayArray", + ID: "test_response_string_array_array", } ) - request, close, err := s.decodeTestResponseStringBinaryNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85387,13 +85396,13 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0 } }() - var response [][]NilString + var response [][]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringBinaryNullableArrayArray", + OperationName: "TestResponseStringArrayArray", OperationSummary: "", - OperationID: "test_response_string_binary_nullable_array_array", + OperationID: "test_response_string_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85402,7 +85411,7 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0 type ( Request = string Params = struct{} - Response = [][]NilString + Response = [][]string ) response, err = middleware.HookMiddleware[ Request, @@ -85413,12 +85422,12 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0 mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringBinaryNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringBinaryNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -85426,7 +85435,7 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0 return } - if err := encodeTestResponseStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85435,18 +85444,18 @@ func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0 } } -// handleTestResponseStringByteRequest handles test_response_string_byte operation. +// handleTestResponseStringBase64Request handles test_response_string_base64 operation. // -// POST /test_response_string_byte -func (s *Server) handleTestResponseStringByteRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_base64 +func (s *Server) handleTestResponseStringBase64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_byte"), + otelogen.OperationID("test_response_string_base64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_byte"), + semconv.HTTPRouteKey.String("/test_response_string_base64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByte", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85471,11 +85480,11 @@ func (s *Server) handleTestResponseStringByteRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringByte", - ID: "test_response_string_byte", + Name: "TestResponseStringBase64", + ID: "test_response_string_base64", } ) - request, close, err := s.decodeTestResponseStringByteRequest(r) + request, close, err := s.decodeTestResponseStringBase64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85495,9 +85504,9 @@ func (s *Server) handleTestResponseStringByteRequest(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringByte", + OperationName: "TestResponseStringBase64", OperationSummary: "", - OperationID: "test_response_string_byte", + OperationID: "test_response_string_base64", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85517,12 +85526,12 @@ func (s *Server) handleTestResponseStringByteRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringByte(ctx, request) + response, err = s.h.TestResponseStringBase64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringByte(ctx, request) + response, err = s.h.TestResponseStringBase64(ctx, request) } if err != nil { recordError("Internal", err) @@ -85530,7 +85539,7 @@ func (s *Server) handleTestResponseStringByteRequest(args [0]string, argsEscaped return } - if err := encodeTestResponseStringByteResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBase64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85539,18 +85548,18 @@ func (s *Server) handleTestResponseStringByteRequest(args [0]string, argsEscaped } } -// handleTestResponseStringByteArrayRequest handles test_response_string_byte_array operation. +// handleTestResponseStringBase64ArrayRequest handles test_response_string_base64_array operation. // -// POST /test_response_string_byte_array -func (s *Server) handleTestResponseStringByteArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_base64_array +func (s *Server) handleTestResponseStringBase64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_byte_array"), + otelogen.OperationID("test_response_string_base64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_byte_array"), + semconv.HTTPRouteKey.String("/test_response_string_base64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85575,11 +85584,11 @@ func (s *Server) handleTestResponseStringByteArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringByteArray", - ID: "test_response_string_byte_array", + Name: "TestResponseStringBase64Array", + ID: "test_response_string_base64_array", } ) - request, close, err := s.decodeTestResponseStringByteArrayRequest(r) + request, close, err := s.decodeTestResponseStringBase64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85599,9 +85608,9 @@ func (s *Server) handleTestResponseStringByteArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringByteArray", + OperationName: "TestResponseStringBase64Array", OperationSummary: "", - OperationID: "test_response_string_byte_array", + OperationID: "test_response_string_base64_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85621,12 +85630,12 @@ func (s *Server) handleTestResponseStringByteArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringByteArray(ctx, request) + response, err = s.h.TestResponseStringBase64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringByteArray(ctx, request) + response, err = s.h.TestResponseStringBase64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -85634,7 +85643,7 @@ func (s *Server) handleTestResponseStringByteArrayRequest(args [0]string, argsEs return } - if err := encodeTestResponseStringByteArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBase64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85643,18 +85652,18 @@ func (s *Server) handleTestResponseStringByteArrayRequest(args [0]string, argsEs } } -// handleTestResponseStringByteArrayArrayRequest handles test_response_string_byte_array_array operation. +// handleTestResponseStringBase64ArrayArrayRequest handles test_response_string_base64_array_array operation. // -// POST /test_response_string_byte_array_array -func (s *Server) handleTestResponseStringByteArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_base64_array_array +func (s *Server) handleTestResponseStringBase64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_byte_array_array"), + otelogen.OperationID("test_response_string_base64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_byte_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_base64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85679,11 +85688,11 @@ func (s *Server) handleTestResponseStringByteArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringByteArrayArray", - ID: "test_response_string_byte_array_array", + Name: "TestResponseStringBase64ArrayArray", + ID: "test_response_string_base64_array_array", } ) - request, close, err := s.decodeTestResponseStringByteArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringBase64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85703,9 +85712,9 @@ func (s *Server) handleTestResponseStringByteArrayArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringByteArrayArray", + OperationName: "TestResponseStringBase64ArrayArray", OperationSummary: "", - OperationID: "test_response_string_byte_array_array", + OperationID: "test_response_string_base64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85725,12 +85734,12 @@ func (s *Server) handleTestResponseStringByteArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringByteArrayArray(ctx, request) + response, err = s.h.TestResponseStringBase64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringByteArrayArray(ctx, request) + response, err = s.h.TestResponseStringBase64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -85738,7 +85747,7 @@ func (s *Server) handleTestResponseStringByteArrayArrayRequest(args [0]string, a return } - if err := encodeTestResponseStringByteArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBase64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85747,18 +85756,18 @@ func (s *Server) handleTestResponseStringByteArrayArrayRequest(args [0]string, a } } -// handleTestResponseStringByteNullableRequest handles test_response_string_byte_nullable operation. +// handleTestResponseStringBase64NullableRequest handles test_response_string_base64_nullable operation. // -// POST /test_response_string_byte_nullable -func (s *Server) handleTestResponseStringByteNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_base64_nullable +func (s *Server) handleTestResponseStringBase64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_byte_nullable"), + otelogen.OperationID("test_response_string_base64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_byte_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_base64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85783,11 +85792,11 @@ func (s *Server) handleTestResponseStringByteNullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringByteNullable", - ID: "test_response_string_byte_nullable", + Name: "TestResponseStringBase64Nullable", + ID: "test_response_string_base64_nullable", } ) - request, close, err := s.decodeTestResponseStringByteNullableRequest(r) + request, close, err := s.decodeTestResponseStringBase64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85807,9 +85816,9 @@ func (s *Server) handleTestResponseStringByteNullableRequest(args [0]string, arg if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringByteNullable", + OperationName: "TestResponseStringBase64Nullable", OperationSummary: "", - OperationID: "test_response_string_byte_nullable", + OperationID: "test_response_string_base64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85829,12 +85838,12 @@ func (s *Server) handleTestResponseStringByteNullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringByteNullable(ctx, request) + response, err = s.h.TestResponseStringBase64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringByteNullable(ctx, request) + response, err = s.h.TestResponseStringBase64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -85842,7 +85851,7 @@ func (s *Server) handleTestResponseStringByteNullableRequest(args [0]string, arg return } - if err := encodeTestResponseStringByteNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBase64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85851,18 +85860,18 @@ func (s *Server) handleTestResponseStringByteNullableRequest(args [0]string, arg } } -// handleTestResponseStringByteNullableArrayRequest handles test_response_string_byte_nullable_array operation. +// handleTestResponseStringBase64NullableArrayRequest handles test_response_string_base64_nullable_array operation. // -// POST /test_response_string_byte_nullable_array -func (s *Server) handleTestResponseStringByteNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_base64_nullable_array +func (s *Server) handleTestResponseStringBase64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_byte_nullable_array"), + otelogen.OperationID("test_response_string_base64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_byte_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_base64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85887,11 +85896,11 @@ func (s *Server) handleTestResponseStringByteNullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringByteNullableArray", - ID: "test_response_string_byte_nullable_array", + Name: "TestResponseStringBase64NullableArray", + ID: "test_response_string_base64_nullable_array", } ) - request, close, err := s.decodeTestResponseStringByteNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringBase64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -85911,9 +85920,9 @@ func (s *Server) handleTestResponseStringByteNullableArrayRequest(args [0]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringByteNullableArray", + OperationName: "TestResponseStringBase64NullableArray", OperationSummary: "", - OperationID: "test_response_string_byte_nullable_array", + OperationID: "test_response_string_base64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -85933,12 +85942,12 @@ func (s *Server) handleTestResponseStringByteNullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringByteNullableArray(ctx, request) + response, err = s.h.TestResponseStringBase64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringByteNullableArray(ctx, request) + response, err = s.h.TestResponseStringBase64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -85946,7 +85955,7 @@ func (s *Server) handleTestResponseStringByteNullableArrayRequest(args [0]string return } - if err := encodeTestResponseStringByteNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBase64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -85955,18 +85964,18 @@ func (s *Server) handleTestResponseStringByteNullableArrayRequest(args [0]string } } -// handleTestResponseStringByteNullableArrayArrayRequest handles test_response_string_byte_nullable_array_array operation. +// handleTestResponseStringBase64NullableArrayArrayRequest handles test_response_string_base64_nullable_array_array operation. // -// POST /test_response_string_byte_nullable_array_array -func (s *Server) handleTestResponseStringByteNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_base64_nullable_array_array +func (s *Server) handleTestResponseStringBase64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_byte_nullable_array_array"), + otelogen.OperationID("test_response_string_base64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_byte_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_base64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBase64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -85991,11 +86000,11 @@ func (s *Server) handleTestResponseStringByteNullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringByteNullableArrayArray", - ID: "test_response_string_byte_nullable_array_array", + Name: "TestResponseStringBase64NullableArrayArray", + ID: "test_response_string_base64_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringByteNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringBase64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86015,9 +86024,9 @@ func (s *Server) handleTestResponseStringByteNullableArrayArrayRequest(args [0]s if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringByteNullableArrayArray", + OperationName: "TestResponseStringBase64NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_byte_nullable_array_array", + OperationID: "test_response_string_base64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86037,12 +86046,12 @@ func (s *Server) handleTestResponseStringByteNullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringByteNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringBase64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringByteNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringBase64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -86050,7 +86059,7 @@ func (s *Server) handleTestResponseStringByteNullableArrayArrayRequest(args [0]s return } - if err := encodeTestResponseStringByteNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBase64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86059,18 +86068,18 @@ func (s *Server) handleTestResponseStringByteNullableArrayArrayRequest(args [0]s } } -// handleTestResponseStringDateRequest handles test_response_string_date operation. +// handleTestResponseStringBinaryRequest handles test_response_string_binary operation. // -// POST /test_response_string_date -func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_binary +func (s *Server) handleTestResponseStringBinaryRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date"), + otelogen.OperationID("test_response_string_binary"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date"), + semconv.HTTPRouteKey.String("/test_response_string_binary"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDate", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinary", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86095,11 +86104,11 @@ func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDate", - ID: "test_response_string_date", + Name: "TestResponseStringBinary", + ID: "test_response_string_binary", } ) - request, close, err := s.decodeTestResponseStringDateRequest(r) + request, close, err := s.decodeTestResponseStringBinaryRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86115,13 +86124,13 @@ func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped } }() - var response time.Time + var response string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDate", + OperationName: "TestResponseStringBinary", OperationSummary: "", - OperationID: "test_response_string_date", + OperationID: "test_response_string_binary", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86130,7 +86139,7 @@ func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped type ( Request = string Params = struct{} - Response = time.Time + Response = string ) response, err = middleware.HookMiddleware[ Request, @@ -86141,12 +86150,12 @@ func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDate(ctx, request) + response, err = s.h.TestResponseStringBinary(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDate(ctx, request) + response, err = s.h.TestResponseStringBinary(ctx, request) } if err != nil { recordError("Internal", err) @@ -86154,7 +86163,7 @@ func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped return } - if err := encodeTestResponseStringDateResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBinaryResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86163,18 +86172,18 @@ func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped } } -// handleTestResponseStringDateArrayRequest handles test_response_string_date_array operation. +// handleTestResponseStringBinaryArrayRequest handles test_response_string_binary_array operation. // -// POST /test_response_string_date_array -func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_binary_array +func (s *Server) handleTestResponseStringBinaryArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date_array"), + otelogen.OperationID("test_response_string_binary_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date_array"), + semconv.HTTPRouteKey.String("/test_response_string_binary_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86199,11 +86208,11 @@ func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateArray", - ID: "test_response_string_date_array", + Name: "TestResponseStringBinaryArray", + ID: "test_response_string_binary_array", } ) - request, close, err := s.decodeTestResponseStringDateArrayRequest(r) + request, close, err := s.decodeTestResponseStringBinaryArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86219,13 +86228,13 @@ func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEs } }() - var response []time.Time + var response []string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateArray", + OperationName: "TestResponseStringBinaryArray", OperationSummary: "", - OperationID: "test_response_string_date_array", + OperationID: "test_response_string_binary_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86234,7 +86243,7 @@ func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEs type ( Request = string Params = struct{} - Response = []time.Time + Response = []string ) response, err = middleware.HookMiddleware[ Request, @@ -86245,12 +86254,12 @@ func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateArray(ctx, request) + response, err = s.h.TestResponseStringBinaryArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateArray(ctx, request) + response, err = s.h.TestResponseStringBinaryArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -86258,7 +86267,7 @@ func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEs return } - if err := encodeTestResponseStringDateArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBinaryArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86267,18 +86276,18 @@ func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEs } } -// handleTestResponseStringDateArrayArrayRequest handles test_response_string_date_array_array operation. +// handleTestResponseStringBinaryArrayArrayRequest handles test_response_string_binary_array_array operation. // -// POST /test_response_string_date_array_array -func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_binary_array_array +func (s *Server) handleTestResponseStringBinaryArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date_array_array"), + otelogen.OperationID("test_response_string_binary_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_binary_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86303,11 +86312,11 @@ func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateArrayArray", - ID: "test_response_string_date_array_array", + Name: "TestResponseStringBinaryArrayArray", + ID: "test_response_string_binary_array_array", } ) - request, close, err := s.decodeTestResponseStringDateArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringBinaryArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86323,13 +86332,13 @@ func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, a } }() - var response [][]time.Time + var response [][]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateArrayArray", + OperationName: "TestResponseStringBinaryArrayArray", OperationSummary: "", - OperationID: "test_response_string_date_array_array", + OperationID: "test_response_string_binary_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86338,7 +86347,7 @@ func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, a type ( Request = string Params = struct{} - Response = [][]time.Time + Response = [][]string ) response, err = middleware.HookMiddleware[ Request, @@ -86349,12 +86358,12 @@ func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateArrayArray(ctx, request) + response, err = s.h.TestResponseStringBinaryArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateArrayArray(ctx, request) + response, err = s.h.TestResponseStringBinaryArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -86362,7 +86371,7 @@ func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, a return } - if err := encodeTestResponseStringDateArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBinaryArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86371,18 +86380,18 @@ func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, a } } -// handleTestResponseStringDateNullableRequest handles test_response_string_date_nullable operation. +// handleTestResponseStringBinaryNullableRequest handles test_response_string_binary_nullable operation. // -// POST /test_response_string_date_nullable -func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_binary_nullable +func (s *Server) handleTestResponseStringBinaryNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date_nullable"), + otelogen.OperationID("test_response_string_binary_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_binary_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86407,11 +86416,11 @@ func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateNullable", - ID: "test_response_string_date_nullable", + Name: "TestResponseStringBinaryNullable", + ID: "test_response_string_binary_nullable", } ) - request, close, err := s.decodeTestResponseStringDateNullableRequest(r) + request, close, err := s.decodeTestResponseStringBinaryNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86427,13 +86436,13 @@ func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, arg } }() - var response NilDate + var response NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateNullable", + OperationName: "TestResponseStringBinaryNullable", OperationSummary: "", - OperationID: "test_response_string_date_nullable", + OperationID: "test_response_string_binary_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86442,7 +86451,7 @@ func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = NilDate + Response = NilString ) response, err = middleware.HookMiddleware[ Request, @@ -86453,12 +86462,12 @@ func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateNullable(ctx, request) + response, err = s.h.TestResponseStringBinaryNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateNullable(ctx, request) + response, err = s.h.TestResponseStringBinaryNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -86466,7 +86475,7 @@ func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, arg return } - if err := encodeTestResponseStringDateNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBinaryNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86475,18 +86484,18 @@ func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, arg } } -// handleTestResponseStringDateNullableArrayRequest handles test_response_string_date_nullable_array operation. +// handleTestResponseStringBinaryNullableArrayRequest handles test_response_string_binary_nullable_array operation. // -// POST /test_response_string_date_nullable_array -func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_binary_nullable_array +func (s *Server) handleTestResponseStringBinaryNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date_nullable_array"), + otelogen.OperationID("test_response_string_binary_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_binary_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86511,11 +86520,11 @@ func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateNullableArray", - ID: "test_response_string_date_nullable_array", + Name: "TestResponseStringBinaryNullableArray", + ID: "test_response_string_binary_nullable_array", } ) - request, close, err := s.decodeTestResponseStringDateNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringBinaryNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86531,13 +86540,13 @@ func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string } }() - var response []NilDate + var response []NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateNullableArray", + OperationName: "TestResponseStringBinaryNullableArray", OperationSummary: "", - OperationID: "test_response_string_date_nullable_array", + OperationID: "test_response_string_binary_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86546,7 +86555,7 @@ func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = []NilDate + Response = []NilString ) response, err = middleware.HookMiddleware[ Request, @@ -86557,12 +86566,12 @@ func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateNullableArray(ctx, request) + response, err = s.h.TestResponseStringBinaryNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateNullableArray(ctx, request) + response, err = s.h.TestResponseStringBinaryNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -86570,7 +86579,7 @@ func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string return } - if err := encodeTestResponseStringDateNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBinaryNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86579,18 +86588,18 @@ func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string } } -// handleTestResponseStringDateNullableArrayArrayRequest handles test_response_string_date_nullable_array_array operation. +// handleTestResponseStringBinaryNullableArrayArrayRequest handles test_response_string_binary_nullable_array_array operation. // -// POST /test_response_string_date_nullable_array_array -func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_binary_nullable_array_array +func (s *Server) handleTestResponseStringBinaryNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date_nullable_array_array"), + otelogen.OperationID("test_response_string_binary_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_binary_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringBinaryNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86615,11 +86624,11 @@ func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateNullableArrayArray", - ID: "test_response_string_date_nullable_array_array", + Name: "TestResponseStringBinaryNullableArrayArray", + ID: "test_response_string_binary_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringDateNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringBinaryNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86635,13 +86644,13 @@ func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]s } }() - var response [][]NilDate + var response [][]NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateNullableArrayArray", + OperationName: "TestResponseStringBinaryNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_date_nullable_array_array", + OperationID: "test_response_string_binary_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86650,7 +86659,7 @@ func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]s type ( Request = string Params = struct{} - Response = [][]NilDate + Response = [][]NilString ) response, err = middleware.HookMiddleware[ Request, @@ -86661,12 +86670,12 @@ func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringBinaryNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringBinaryNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -86674,7 +86683,7 @@ func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]s return } - if err := encodeTestResponseStringDateNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringBinaryNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86683,18 +86692,18 @@ func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]s } } -// handleTestResponseStringDateTimeRequest handles test_response_string_date-time operation. +// handleTestResponseStringByteRequest handles test_response_string_byte operation. // -// POST /test_response_string_date-time -func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_byte +func (s *Server) handleTestResponseStringByteRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date-time"), + otelogen.OperationID("test_response_string_byte"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date-time"), + semconv.HTTPRouteKey.String("/test_response_string_byte"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTime", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByte", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86719,11 +86728,11 @@ func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateTime", - ID: "test_response_string_date-time", + Name: "TestResponseStringByte", + ID: "test_response_string_byte", } ) - request, close, err := s.decodeTestResponseStringDateTimeRequest(r) + request, close, err := s.decodeTestResponseStringByteRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86739,13 +86748,13 @@ func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEsc } }() - var response time.Time + var response []byte if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateTime", + OperationName: "TestResponseStringByte", OperationSummary: "", - OperationID: "test_response_string_date-time", + OperationID: "test_response_string_byte", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86754,7 +86763,7 @@ func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEsc type ( Request = string Params = struct{} - Response = time.Time + Response = []byte ) response, err = middleware.HookMiddleware[ Request, @@ -86765,12 +86774,12 @@ func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateTime(ctx, request) + response, err = s.h.TestResponseStringByte(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateTime(ctx, request) + response, err = s.h.TestResponseStringByte(ctx, request) } if err != nil { recordError("Internal", err) @@ -86778,7 +86787,7 @@ func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEsc return } - if err := encodeTestResponseStringDateTimeResponse(response, w, span); err != nil { + if err := encodeTestResponseStringByteResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86787,18 +86796,18 @@ func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEsc } } -// handleTestResponseStringDateTimeArrayRequest handles test_response_string_date-time_array operation. +// handleTestResponseStringByteArrayRequest handles test_response_string_byte_array operation. // -// POST /test_response_string_date-time_array -func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_byte_array +func (s *Server) handleTestResponseStringByteArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date-time_array"), + otelogen.OperationID("test_response_string_byte_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date-time_array"), + semconv.HTTPRouteKey.String("/test_response_string_byte_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86823,11 +86832,11 @@ func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateTimeArray", - ID: "test_response_string_date-time_array", + Name: "TestResponseStringByteArray", + ID: "test_response_string_byte_array", } ) - request, close, err := s.decodeTestResponseStringDateTimeArrayRequest(r) + request, close, err := s.decodeTestResponseStringByteArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86843,13 +86852,13 @@ func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, ar } }() - var response []time.Time + var response [][]byte if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateTimeArray", + OperationName: "TestResponseStringByteArray", OperationSummary: "", - OperationID: "test_response_string_date-time_array", + OperationID: "test_response_string_byte_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86858,7 +86867,7 @@ func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = []time.Time + Response = [][]byte ) response, err = middleware.HookMiddleware[ Request, @@ -86869,12 +86878,12 @@ func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateTimeArray(ctx, request) + response, err = s.h.TestResponseStringByteArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateTimeArray(ctx, request) + response, err = s.h.TestResponseStringByteArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -86882,7 +86891,7 @@ func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, ar return } - if err := encodeTestResponseStringDateTimeArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringByteArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86891,18 +86900,18 @@ func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, ar } } -// handleTestResponseStringDateTimeArrayArrayRequest handles test_response_string_date-time_array_array operation. +// handleTestResponseStringByteArrayArrayRequest handles test_response_string_byte_array_array operation. // -// POST /test_response_string_date-time_array_array -func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_byte_array_array +func (s *Server) handleTestResponseStringByteArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date-time_array_array"), + otelogen.OperationID("test_response_string_byte_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date-time_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_byte_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -86927,11 +86936,11 @@ func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateTimeArrayArray", - ID: "test_response_string_date-time_array_array", + Name: "TestResponseStringByteArrayArray", + ID: "test_response_string_byte_array_array", } ) - request, close, err := s.decodeTestResponseStringDateTimeArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringByteArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -86947,13 +86956,13 @@ func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]strin } }() - var response [][]time.Time + var response [][][]byte if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateTimeArrayArray", + OperationName: "TestResponseStringByteArrayArray", OperationSummary: "", - OperationID: "test_response_string_date-time_array_array", + OperationID: "test_response_string_byte_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -86962,7 +86971,7 @@ func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = [][]time.Time + Response = [][][]byte ) response, err = middleware.HookMiddleware[ Request, @@ -86973,12 +86982,12 @@ func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateTimeArrayArray(ctx, request) + response, err = s.h.TestResponseStringByteArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateTimeArrayArray(ctx, request) + response, err = s.h.TestResponseStringByteArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -86986,7 +86995,7 @@ func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]strin return } - if err := encodeTestResponseStringDateTimeArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringByteArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -86995,18 +87004,18 @@ func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]strin } } -// handleTestResponseStringDateTimeNullableRequest handles test_response_string_date-time_nullable operation. +// handleTestResponseStringByteNullableRequest handles test_response_string_byte_nullable operation. // -// POST /test_response_string_date-time_nullable -func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_byte_nullable +func (s *Server) handleTestResponseStringByteNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date-time_nullable"), + otelogen.OperationID("test_response_string_byte_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date-time_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_byte_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87031,11 +87040,11 @@ func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateTimeNullable", - ID: "test_response_string_date-time_nullable", + Name: "TestResponseStringByteNullable", + ID: "test_response_string_byte_nullable", } ) - request, close, err := s.decodeTestResponseStringDateTimeNullableRequest(r) + request, close, err := s.decodeTestResponseStringByteNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87051,13 +87060,13 @@ func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, } }() - var response NilDateTime + var response []byte if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateTimeNullable", + OperationName: "TestResponseStringByteNullable", OperationSummary: "", - OperationID: "test_response_string_date-time_nullable", + OperationID: "test_response_string_byte_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87066,7 +87075,7 @@ func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilDateTime + Response = []byte ) response, err = middleware.HookMiddleware[ Request, @@ -87077,12 +87086,12 @@ func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateTimeNullable(ctx, request) + response, err = s.h.TestResponseStringByteNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateTimeNullable(ctx, request) + response, err = s.h.TestResponseStringByteNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -87090,7 +87099,7 @@ func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, return } - if err := encodeTestResponseStringDateTimeNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringByteNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87099,18 +87108,18 @@ func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, } } -// handleTestResponseStringDateTimeNullableArrayRequest handles test_response_string_date-time_nullable_array operation. +// handleTestResponseStringByteNullableArrayRequest handles test_response_string_byte_nullable_array operation. // -// POST /test_response_string_date-time_nullable_array -func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_byte_nullable_array +func (s *Server) handleTestResponseStringByteNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date-time_nullable_array"), + otelogen.OperationID("test_response_string_byte_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date-time_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_byte_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87135,11 +87144,11 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateTimeNullableArray", - ID: "test_response_string_date-time_nullable_array", + Name: "TestResponseStringByteNullableArray", + ID: "test_response_string_byte_nullable_array", } ) - request, close, err := s.decodeTestResponseStringDateTimeNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringByteNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87155,13 +87164,13 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]st } }() - var response []NilDateTime + var response [][]byte if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateTimeNullableArray", + OperationName: "TestResponseStringByteNullableArray", OperationSummary: "", - OperationID: "test_response_string_date-time_nullable_array", + OperationID: "test_response_string_byte_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87170,7 +87179,7 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]st type ( Request = string Params = struct{} - Response = []NilDateTime + Response = [][]byte ) response, err = middleware.HookMiddleware[ Request, @@ -87181,12 +87190,12 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateTimeNullableArray(ctx, request) + response, err = s.h.TestResponseStringByteNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateTimeNullableArray(ctx, request) + response, err = s.h.TestResponseStringByteNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -87194,7 +87203,7 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]st return } - if err := encodeTestResponseStringDateTimeNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringByteNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87203,18 +87212,18 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]st } } -// handleTestResponseStringDateTimeNullableArrayArrayRequest handles test_response_string_date-time_nullable_array_array operation. +// handleTestResponseStringByteNullableArrayArrayRequest handles test_response_string_byte_nullable_array_array operation. // -// POST /test_response_string_date-time_nullable_array_array -func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_byte_nullable_array_array +func (s *Server) handleTestResponseStringByteNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_date-time_nullable_array_array"), + otelogen.OperationID("test_response_string_byte_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_date-time_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_byte_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringByteNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87239,11 +87248,11 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDateTimeNullableArrayArray", - ID: "test_response_string_date-time_nullable_array_array", + Name: "TestResponseStringByteNullableArrayArray", + ID: "test_response_string_byte_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringDateTimeNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringByteNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87259,13 +87268,13 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args } }() - var response [][]NilDateTime + var response [][][]byte if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDateTimeNullableArrayArray", + OperationName: "TestResponseStringByteNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_date-time_nullable_array_array", + OperationID: "test_response_string_byte_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87274,7 +87283,7 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args type ( Request = string Params = struct{} - Response = [][]NilDateTime + Response = [][][]byte ) response, err = middleware.HookMiddleware[ Request, @@ -87285,12 +87294,12 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDateTimeNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringByteNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDateTimeNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringByteNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -87298,7 +87307,7 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args return } - if err := encodeTestResponseStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringByteNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87307,18 +87316,18 @@ func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args } } -// handleTestResponseStringDurationRequest handles test_response_string_duration operation. +// handleTestResponseStringDateRequest handles test_response_string_date operation. // -// POST /test_response_string_duration -func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date +func (s *Server) handleTestResponseStringDateRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_duration"), + otelogen.OperationID("test_response_string_date"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_duration"), + semconv.HTTPRouteKey.String("/test_response_string_date"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDuration", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDate", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87343,11 +87352,11 @@ func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDuration", - ID: "test_response_string_duration", + Name: "TestResponseStringDate", + ID: "test_response_string_date", } ) - request, close, err := s.decodeTestResponseStringDurationRequest(r) + request, close, err := s.decodeTestResponseStringDateRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87363,13 +87372,13 @@ func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEsc } }() - var response time.Duration + var response time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDuration", + OperationName: "TestResponseStringDate", OperationSummary: "", - OperationID: "test_response_string_duration", + OperationID: "test_response_string_date", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87378,7 +87387,7 @@ func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEsc type ( Request = string Params = struct{} - Response = time.Duration + Response = time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -87389,12 +87398,12 @@ func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDuration(ctx, request) + response, err = s.h.TestResponseStringDate(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDuration(ctx, request) + response, err = s.h.TestResponseStringDate(ctx, request) } if err != nil { recordError("Internal", err) @@ -87402,7 +87411,7 @@ func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEsc return } - if err := encodeTestResponseStringDurationResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87411,18 +87420,18 @@ func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEsc } } -// handleTestResponseStringDurationArrayRequest handles test_response_string_duration_array operation. +// handleTestResponseStringDateArrayRequest handles test_response_string_date_array operation. // -// POST /test_response_string_duration_array -func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date_array +func (s *Server) handleTestResponseStringDateArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_duration_array"), + otelogen.OperationID("test_response_string_date_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_duration_array"), + semconv.HTTPRouteKey.String("/test_response_string_date_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87447,11 +87456,11 @@ func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDurationArray", - ID: "test_response_string_duration_array", + Name: "TestResponseStringDateArray", + ID: "test_response_string_date_array", } ) - request, close, err := s.decodeTestResponseStringDurationArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87467,13 +87476,13 @@ func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, ar } }() - var response []time.Duration + var response []time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDurationArray", + OperationName: "TestResponseStringDateArray", OperationSummary: "", - OperationID: "test_response_string_duration_array", + OperationID: "test_response_string_date_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87482,7 +87491,7 @@ func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = []time.Duration + Response = []time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -87493,12 +87502,12 @@ func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDurationArray(ctx, request) + response, err = s.h.TestResponseStringDateArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDurationArray(ctx, request) + response, err = s.h.TestResponseStringDateArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -87506,7 +87515,7 @@ func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, ar return } - if err := encodeTestResponseStringDurationArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87515,18 +87524,18 @@ func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, ar } } -// handleTestResponseStringDurationArrayArrayRequest handles test_response_string_duration_array_array operation. +// handleTestResponseStringDateArrayArrayRequest handles test_response_string_date_array_array operation. // -// POST /test_response_string_duration_array_array -func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date_array_array +func (s *Server) handleTestResponseStringDateArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_duration_array_array"), + otelogen.OperationID("test_response_string_date_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_duration_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_date_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87551,11 +87560,11 @@ func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDurationArrayArray", - ID: "test_response_string_duration_array_array", + Name: "TestResponseStringDateArrayArray", + ID: "test_response_string_date_array_array", } ) - request, close, err := s.decodeTestResponseStringDurationArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87571,13 +87580,13 @@ func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]strin } }() - var response [][]time.Duration + var response [][]time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDurationArrayArray", + OperationName: "TestResponseStringDateArrayArray", OperationSummary: "", - OperationID: "test_response_string_duration_array_array", + OperationID: "test_response_string_date_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87586,7 +87595,7 @@ func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = [][]time.Duration + Response = [][]time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -87597,12 +87606,12 @@ func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDurationArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDurationArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -87610,7 +87619,7 @@ func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]strin return } - if err := encodeTestResponseStringDurationArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87619,18 +87628,18 @@ func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]strin } } -// handleTestResponseStringDurationNullableRequest handles test_response_string_duration_nullable operation. +// handleTestResponseStringDateNullableRequest handles test_response_string_date_nullable operation. // -// POST /test_response_string_duration_nullable -func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date_nullable +func (s *Server) handleTestResponseStringDateNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_duration_nullable"), + otelogen.OperationID("test_response_string_date_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_duration_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_date_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87655,11 +87664,11 @@ func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDurationNullable", - ID: "test_response_string_duration_nullable", + Name: "TestResponseStringDateNullable", + ID: "test_response_string_date_nullable", } ) - request, close, err := s.decodeTestResponseStringDurationNullableRequest(r) + request, close, err := s.decodeTestResponseStringDateNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87675,13 +87684,13 @@ func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, } }() - var response NilDuration + var response NilDate if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDurationNullable", + OperationName: "TestResponseStringDateNullable", OperationSummary: "", - OperationID: "test_response_string_duration_nullable", + OperationID: "test_response_string_date_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87690,7 +87699,7 @@ func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilDuration + Response = NilDate ) response, err = middleware.HookMiddleware[ Request, @@ -87701,12 +87710,12 @@ func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDurationNullable(ctx, request) + response, err = s.h.TestResponseStringDateNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDurationNullable(ctx, request) + response, err = s.h.TestResponseStringDateNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -87714,7 +87723,7 @@ func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, return } - if err := encodeTestResponseStringDurationNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87723,18 +87732,18 @@ func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, } } -// handleTestResponseStringDurationNullableArrayRequest handles test_response_string_duration_nullable_array operation. +// handleTestResponseStringDateNullableArrayRequest handles test_response_string_date_nullable_array operation. // -// POST /test_response_string_duration_nullable_array -func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date_nullable_array +func (s *Server) handleTestResponseStringDateNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_duration_nullable_array"), + otelogen.OperationID("test_response_string_date_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_duration_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_date_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87759,11 +87768,11 @@ func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDurationNullableArray", - ID: "test_response_string_duration_nullable_array", + Name: "TestResponseStringDateNullableArray", + ID: "test_response_string_date_nullable_array", } ) - request, close, err := s.decodeTestResponseStringDurationNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87779,13 +87788,13 @@ func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]st } }() - var response []NilDuration + var response []NilDate if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDurationNullableArray", + OperationName: "TestResponseStringDateNullableArray", OperationSummary: "", - OperationID: "test_response_string_duration_nullable_array", + OperationID: "test_response_string_date_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87794,7 +87803,7 @@ func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]st type ( Request = string Params = struct{} - Response = []NilDuration + Response = []NilDate ) response, err = middleware.HookMiddleware[ Request, @@ -87805,12 +87814,12 @@ func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDurationNullableArray(ctx, request) + response, err = s.h.TestResponseStringDateNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDurationNullableArray(ctx, request) + response, err = s.h.TestResponseStringDateNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -87818,7 +87827,7 @@ func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]st return } - if err := encodeTestResponseStringDurationNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87827,18 +87836,18 @@ func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]st } } -// handleTestResponseStringDurationNullableArrayArrayRequest handles test_response_string_duration_nullable_array_array operation. +// handleTestResponseStringDateNullableArrayArrayRequest handles test_response_string_date_nullable_array_array operation. // -// POST /test_response_string_duration_nullable_array_array -func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date_nullable_array_array +func (s *Server) handleTestResponseStringDateNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_duration_nullable_array_array"), + otelogen.OperationID("test_response_string_date_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_duration_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_date_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87863,11 +87872,11 @@ func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringDurationNullableArrayArray", - ID: "test_response_string_duration_nullable_array_array", + Name: "TestResponseStringDateNullableArrayArray", + ID: "test_response_string_date_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringDurationNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87883,13 +87892,13 @@ func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args } }() - var response [][]NilDuration + var response [][]NilDate if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringDurationNullableArrayArray", + OperationName: "TestResponseStringDateNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_duration_nullable_array_array", + OperationID: "test_response_string_date_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -87898,7 +87907,7 @@ func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args type ( Request = string Params = struct{} - Response = [][]NilDuration + Response = [][]NilDate ) response, err = middleware.HookMiddleware[ Request, @@ -87909,12 +87918,12 @@ func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringDurationNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringDurationNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -87922,7 +87931,7 @@ func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args return } - if err := encodeTestResponseStringDurationNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -87931,18 +87940,18 @@ func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args } } -// handleTestResponseStringEmailRequest handles test_response_string_email operation. +// handleTestResponseStringDateTimeRequest handles test_response_string_date-time operation. // -// POST /test_response_string_email -func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date-time +func (s *Server) handleTestResponseStringDateTimeRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_email"), + otelogen.OperationID("test_response_string_date-time"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_email"), + semconv.HTTPRouteKey.String("/test_response_string_date-time"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmail", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTime", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -87967,11 +87976,11 @@ func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringEmail", - ID: "test_response_string_email", + Name: "TestResponseStringDateTime", + ID: "test_response_string_date-time", } ) - request, close, err := s.decodeTestResponseStringEmailRequest(r) + request, close, err := s.decodeTestResponseStringDateTimeRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -87987,13 +87996,13 @@ func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscape } }() - var response string + var response time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringEmail", + OperationName: "TestResponseStringDateTime", OperationSummary: "", - OperationID: "test_response_string_email", + OperationID: "test_response_string_date-time", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88002,7 +88011,7 @@ func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = string + Response = time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -88013,12 +88022,12 @@ func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringEmail(ctx, request) + response, err = s.h.TestResponseStringDateTime(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringEmail(ctx, request) + response, err = s.h.TestResponseStringDateTime(ctx, request) } if err != nil { recordError("Internal", err) @@ -88026,7 +88035,7 @@ func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscape return } - if err := encodeTestResponseStringEmailResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateTimeResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88035,18 +88044,18 @@ func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscape } } -// handleTestResponseStringEmailArrayRequest handles test_response_string_email_array operation. +// handleTestResponseStringDateTimeArrayRequest handles test_response_string_date-time_array operation. // -// POST /test_response_string_email_array -func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date-time_array +func (s *Server) handleTestResponseStringDateTimeArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_email_array"), + otelogen.OperationID("test_response_string_date-time_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_email_array"), + semconv.HTTPRouteKey.String("/test_response_string_date-time_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88071,11 +88080,11 @@ func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringEmailArray", - ID: "test_response_string_email_array", + Name: "TestResponseStringDateTimeArray", + ID: "test_response_string_date-time_array", } ) - request, close, err := s.decodeTestResponseStringEmailArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateTimeArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88091,13 +88100,13 @@ func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsE } }() - var response []string + var response []time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringEmailArray", + OperationName: "TestResponseStringDateTimeArray", OperationSummary: "", - OperationID: "test_response_string_email_array", + OperationID: "test_response_string_date-time_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88106,7 +88115,7 @@ func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []string + Response = []time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -88117,12 +88126,12 @@ func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringEmailArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringEmailArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -88130,7 +88139,7 @@ func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseStringEmailArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateTimeArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88139,18 +88148,18 @@ func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsE } } -// handleTestResponseStringEmailArrayArrayRequest handles test_response_string_email_array_array operation. +// handleTestResponseStringDateTimeArrayArrayRequest handles test_response_string_date-time_array_array operation. // -// POST /test_response_string_email_array_array -func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date-time_array_array +func (s *Server) handleTestResponseStringDateTimeArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_email_array_array"), + otelogen.OperationID("test_response_string_date-time_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_email_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_date-time_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88175,11 +88184,11 @@ func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringEmailArrayArray", - ID: "test_response_string_email_array_array", + Name: "TestResponseStringDateTimeArrayArray", + ID: "test_response_string_date-time_array_array", } ) - request, close, err := s.decodeTestResponseStringEmailArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateTimeArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88195,13 +88204,13 @@ func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, } }() - var response [][]string + var response [][]time.Time if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringEmailArrayArray", + OperationName: "TestResponseStringDateTimeArrayArray", OperationSummary: "", - OperationID: "test_response_string_email_array_array", + OperationID: "test_response_string_date-time_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88210,7 +88219,7 @@ func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]string + Response = [][]time.Time ) response, err = middleware.HookMiddleware[ Request, @@ -88221,12 +88230,12 @@ func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringEmailArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringEmailArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -88234,7 +88243,7 @@ func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseStringEmailArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateTimeArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88243,18 +88252,18 @@ func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, } } -// handleTestResponseStringEmailNullableRequest handles test_response_string_email_nullable operation. +// handleTestResponseStringDateTimeNullableRequest handles test_response_string_date-time_nullable operation. // -// POST /test_response_string_email_nullable -func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date-time_nullable +func (s *Server) handleTestResponseStringDateTimeNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_email_nullable"), + otelogen.OperationID("test_response_string_date-time_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_email_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_date-time_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88279,11 +88288,11 @@ func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringEmailNullable", - ID: "test_response_string_email_nullable", + Name: "TestResponseStringDateTimeNullable", + ID: "test_response_string_date-time_nullable", } ) - request, close, err := s.decodeTestResponseStringEmailNullableRequest(r) + request, close, err := s.decodeTestResponseStringDateTimeNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88299,13 +88308,13 @@ func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, ar } }() - var response NilString + var response NilDateTime if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringEmailNullable", + OperationName: "TestResponseStringDateTimeNullable", OperationSummary: "", - OperationID: "test_response_string_email_nullable", + OperationID: "test_response_string_date-time_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88314,7 +88323,7 @@ func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilString + Response = NilDateTime ) response, err = middleware.HookMiddleware[ Request, @@ -88325,12 +88334,12 @@ func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringEmailNullable(ctx, request) + response, err = s.h.TestResponseStringDateTimeNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringEmailNullable(ctx, request) + response, err = s.h.TestResponseStringDateTimeNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -88338,7 +88347,7 @@ func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, ar return } - if err := encodeTestResponseStringEmailNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateTimeNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88347,18 +88356,18 @@ func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, ar } } -// handleTestResponseStringEmailNullableArrayRequest handles test_response_string_email_nullable_array operation. +// handleTestResponseStringDateTimeNullableArrayRequest handles test_response_string_date-time_nullable_array operation. // -// POST /test_response_string_email_nullable_array -func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date-time_nullable_array +func (s *Server) handleTestResponseStringDateTimeNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_email_nullable_array"), + otelogen.OperationID("test_response_string_date-time_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_email_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_date-time_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88383,11 +88392,11 @@ func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringEmailNullableArray", - ID: "test_response_string_email_nullable_array", + Name: "TestResponseStringDateTimeNullableArray", + ID: "test_response_string_date-time_nullable_array", } ) - request, close, err := s.decodeTestResponseStringEmailNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateTimeNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88403,13 +88412,13 @@ func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]strin } }() - var response []NilString + var response []NilDateTime if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringEmailNullableArray", + OperationName: "TestResponseStringDateTimeNullableArray", OperationSummary: "", - OperationID: "test_response_string_email_nullable_array", + OperationID: "test_response_string_date-time_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88418,7 +88427,7 @@ func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilString + Response = []NilDateTime ) response, err = middleware.HookMiddleware[ Request, @@ -88429,12 +88438,12 @@ func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringEmailNullableArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringEmailNullableArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -88442,7 +88451,7 @@ func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]strin return } - if err := encodeTestResponseStringEmailNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateTimeNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88451,18 +88460,18 @@ func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]strin } } -// handleTestResponseStringEmailNullableArrayArrayRequest handles test_response_string_email_nullable_array_array operation. +// handleTestResponseStringDateTimeNullableArrayArrayRequest handles test_response_string_date-time_nullable_array_array operation. // -// POST /test_response_string_email_nullable_array_array -func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_date-time_nullable_array_array +func (s *Server) handleTestResponseStringDateTimeNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_email_nullable_array_array"), + otelogen.OperationID("test_response_string_date-time_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_email_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_date-time_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDateTimeNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88487,11 +88496,11 @@ func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringEmailNullableArrayArray", - ID: "test_response_string_email_nullable_array_array", + Name: "TestResponseStringDateTimeNullableArrayArray", + ID: "test_response_string_date-time_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringEmailNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringDateTimeNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88507,13 +88516,13 @@ func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0] } }() - var response [][]NilString + var response [][]NilDateTime if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringEmailNullableArrayArray", + OperationName: "TestResponseStringDateTimeNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_email_nullable_array_array", + OperationID: "test_response_string_date-time_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88522,7 +88531,7 @@ func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilString + Response = [][]NilDateTime ) response, err = middleware.HookMiddleware[ Request, @@ -88533,12 +88542,12 @@ func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringEmailNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringEmailNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringDateTimeNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -88546,7 +88555,7 @@ func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseStringEmailNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDateTimeNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88555,18 +88564,18 @@ func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0] } } -// handleTestResponseStringFloat32Request handles test_response_string_float32 operation. +// handleTestResponseStringDurationRequest handles test_response_string_duration operation. // -// POST /test_response_string_float32 -func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_duration +func (s *Server) handleTestResponseStringDurationRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float32"), + otelogen.OperationID("test_response_string_duration"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float32"), + semconv.HTTPRouteKey.String("/test_response_string_duration"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDuration", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88591,11 +88600,11 @@ func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat32", - ID: "test_response_string_float32", + Name: "TestResponseStringDuration", + ID: "test_response_string_duration", } ) - request, close, err := s.decodeTestResponseStringFloat32Request(r) + request, close, err := s.decodeTestResponseStringDurationRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88611,13 +88620,13 @@ func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEsca } }() - var response float32 + var response time.Duration if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat32", + OperationName: "TestResponseStringDuration", OperationSummary: "", - OperationID: "test_response_string_float32", + OperationID: "test_response_string_duration", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88626,7 +88635,7 @@ func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEsca type ( Request = string Params = struct{} - Response = float32 + Response = time.Duration ) response, err = middleware.HookMiddleware[ Request, @@ -88637,12 +88646,12 @@ func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat32(ctx, request) + response, err = s.h.TestResponseStringDuration(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat32(ctx, request) + response, err = s.h.TestResponseStringDuration(ctx, request) } if err != nil { recordError("Internal", err) @@ -88650,7 +88659,7 @@ func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEsca return } - if err := encodeTestResponseStringFloat32Response(response, w, span); err != nil { + if err := encodeTestResponseStringDurationResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88659,18 +88668,18 @@ func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEsca } } -// handleTestResponseStringFloat32ArrayRequest handles test_response_string_float32_array operation. +// handleTestResponseStringDurationArrayRequest handles test_response_string_duration_array operation. // -// POST /test_response_string_float32_array -func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_duration_array +func (s *Server) handleTestResponseStringDurationArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float32_array"), + otelogen.OperationID("test_response_string_duration_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float32_array"), + semconv.HTTPRouteKey.String("/test_response_string_duration_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88695,11 +88704,11 @@ func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat32Array", - ID: "test_response_string_float32_array", + Name: "TestResponseStringDurationArray", + ID: "test_response_string_duration_array", } ) - request, close, err := s.decodeTestResponseStringFloat32ArrayRequest(r) + request, close, err := s.decodeTestResponseStringDurationArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88715,13 +88724,13 @@ func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, arg } }() - var response []float32 + var response []time.Duration if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat32Array", + OperationName: "TestResponseStringDurationArray", OperationSummary: "", - OperationID: "test_response_string_float32_array", + OperationID: "test_response_string_duration_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88730,7 +88739,7 @@ func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = []float32 + Response = []time.Duration ) response, err = middleware.HookMiddleware[ Request, @@ -88741,12 +88750,12 @@ func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat32Array(ctx, request) + response, err = s.h.TestResponseStringDurationArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat32Array(ctx, request) + response, err = s.h.TestResponseStringDurationArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -88754,7 +88763,7 @@ func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, arg return } - if err := encodeTestResponseStringFloat32ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDurationArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88763,18 +88772,18 @@ func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, arg } } -// handleTestResponseStringFloat32ArrayArrayRequest handles test_response_string_float32_array_array operation. +// handleTestResponseStringDurationArrayArrayRequest handles test_response_string_duration_array_array operation. // -// POST /test_response_string_float32_array_array -func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_duration_array_array +func (s *Server) handleTestResponseStringDurationArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float32_array_array"), + otelogen.OperationID("test_response_string_duration_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float32_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_duration_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88799,11 +88808,11 @@ func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat32ArrayArray", - ID: "test_response_string_float32_array_array", + Name: "TestResponseStringDurationArrayArray", + ID: "test_response_string_duration_array_array", } ) - request, close, err := s.decodeTestResponseStringFloat32ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringDurationArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88819,13 +88828,13 @@ func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string } }() - var response [][]float32 + var response [][]time.Duration if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat32ArrayArray", + OperationName: "TestResponseStringDurationArrayArray", OperationSummary: "", - OperationID: "test_response_string_float32_array_array", + OperationID: "test_response_string_duration_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88834,7 +88843,7 @@ func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = [][]float32 + Response = [][]time.Duration ) response, err = middleware.HookMiddleware[ Request, @@ -88845,12 +88854,12 @@ func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat32ArrayArray(ctx, request) + response, err = s.h.TestResponseStringDurationArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat32ArrayArray(ctx, request) + response, err = s.h.TestResponseStringDurationArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -88858,7 +88867,7 @@ func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string return } - if err := encodeTestResponseStringFloat32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDurationArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88867,18 +88876,18 @@ func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string } } -// handleTestResponseStringFloat32NullableRequest handles test_response_string_float32_nullable operation. +// handleTestResponseStringDurationNullableRequest handles test_response_string_duration_nullable operation. // -// POST /test_response_string_float32_nullable -func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_duration_nullable +func (s *Server) handleTestResponseStringDurationNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float32_nullable"), + otelogen.OperationID("test_response_string_duration_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float32_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_duration_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -88903,11 +88912,11 @@ func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat32Nullable", - ID: "test_response_string_float32_nullable", + Name: "TestResponseStringDurationNullable", + ID: "test_response_string_duration_nullable", } ) - request, close, err := s.decodeTestResponseStringFloat32NullableRequest(r) + request, close, err := s.decodeTestResponseStringDurationNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -88923,13 +88932,13 @@ func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, } }() - var response NilStringFloat32 + var response NilDuration if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat32Nullable", + OperationName: "TestResponseStringDurationNullable", OperationSummary: "", - OperationID: "test_response_string_float32_nullable", + OperationID: "test_response_string_duration_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -88938,7 +88947,7 @@ func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilStringFloat32 + Response = NilDuration ) response, err = middleware.HookMiddleware[ Request, @@ -88949,12 +88958,12 @@ func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat32Nullable(ctx, request) + response, err = s.h.TestResponseStringDurationNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat32Nullable(ctx, request) + response, err = s.h.TestResponseStringDurationNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -88962,7 +88971,7 @@ func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, return } - if err := encodeTestResponseStringFloat32NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDurationNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -88971,18 +88980,18 @@ func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, } } -// handleTestResponseStringFloat32NullableArrayRequest handles test_response_string_float32_nullable_array operation. +// handleTestResponseStringDurationNullableArrayRequest handles test_response_string_duration_nullable_array operation. // -// POST /test_response_string_float32_nullable_array -func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_duration_nullable_array +func (s *Server) handleTestResponseStringDurationNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float32_nullable_array"), + otelogen.OperationID("test_response_string_duration_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float32_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_duration_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89007,11 +89016,11 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat32NullableArray", - ID: "test_response_string_float32_nullable_array", + Name: "TestResponseStringDurationNullableArray", + ID: "test_response_string_duration_nullable_array", } ) - request, close, err := s.decodeTestResponseStringFloat32NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringDurationNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89027,13 +89036,13 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]str } }() - var response []NilStringFloat32 + var response []NilDuration if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat32NullableArray", + OperationName: "TestResponseStringDurationNullableArray", OperationSummary: "", - OperationID: "test_response_string_float32_nullable_array", + OperationID: "test_response_string_duration_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89042,7 +89051,7 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = []NilStringFloat32 + Response = []NilDuration ) response, err = middleware.HookMiddleware[ Request, @@ -89053,12 +89062,12 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat32NullableArray(ctx, request) + response, err = s.h.TestResponseStringDurationNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat32NullableArray(ctx, request) + response, err = s.h.TestResponseStringDurationNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -89066,7 +89075,7 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]str return } - if err := encodeTestResponseStringFloat32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDurationNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89075,18 +89084,18 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]str } } -// handleTestResponseStringFloat32NullableArrayArrayRequest handles test_response_string_float32_nullable_array_array operation. +// handleTestResponseStringDurationNullableArrayArrayRequest handles test_response_string_duration_nullable_array_array operation. // -// POST /test_response_string_float32_nullable_array_array -func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_duration_nullable_array_array +func (s *Server) handleTestResponseStringDurationNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float32_nullable_array_array"), + otelogen.OperationID("test_response_string_duration_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_duration_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringDurationNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89111,11 +89120,11 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat32NullableArrayArray", - ID: "test_response_string_float32_nullable_array_array", + Name: "TestResponseStringDurationNullableArrayArray", + ID: "test_response_string_duration_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringFloat32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringDurationNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89131,13 +89140,13 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [ } }() - var response [][]NilStringFloat32 + var response [][]NilDuration if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat32NullableArrayArray", + OperationName: "TestResponseStringDurationNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_float32_nullable_array_array", + OperationID: "test_response_string_duration_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89146,7 +89155,7 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [ type ( Request = string Params = struct{} - Response = [][]NilStringFloat32 + Response = [][]NilDuration ) response, err = middleware.HookMiddleware[ Request, @@ -89157,12 +89166,12 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringDurationNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringDurationNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -89170,7 +89179,7 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [ return } - if err := encodeTestResponseStringFloat32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringDurationNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89179,18 +89188,18 @@ func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [ } } -// handleTestResponseStringFloat64Request handles test_response_string_float64 operation. +// handleTestResponseStringEmailRequest handles test_response_string_email operation. // -// POST /test_response_string_float64 -func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_email +func (s *Server) handleTestResponseStringEmailRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float64"), + otelogen.OperationID("test_response_string_email"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float64"), + semconv.HTTPRouteKey.String("/test_response_string_email"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmail", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89215,11 +89224,11 @@ func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat64", - ID: "test_response_string_float64", + Name: "TestResponseStringEmail", + ID: "test_response_string_email", } ) - request, close, err := s.decodeTestResponseStringFloat64Request(r) + request, close, err := s.decodeTestResponseStringEmailRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89235,13 +89244,13 @@ func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEsca } }() - var response float64 + var response string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat64", + OperationName: "TestResponseStringEmail", OperationSummary: "", - OperationID: "test_response_string_float64", + OperationID: "test_response_string_email", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89250,7 +89259,7 @@ func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEsca type ( Request = string Params = struct{} - Response = float64 + Response = string ) response, err = middleware.HookMiddleware[ Request, @@ -89261,12 +89270,12 @@ func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat64(ctx, request) + response, err = s.h.TestResponseStringEmail(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat64(ctx, request) + response, err = s.h.TestResponseStringEmail(ctx, request) } if err != nil { recordError("Internal", err) @@ -89274,7 +89283,7 @@ func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEsca return } - if err := encodeTestResponseStringFloat64Response(response, w, span); err != nil { + if err := encodeTestResponseStringEmailResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89283,18 +89292,18 @@ func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEsca } } -// handleTestResponseStringFloat64ArrayRequest handles test_response_string_float64_array operation. +// handleTestResponseStringEmailArrayRequest handles test_response_string_email_array operation. // -// POST /test_response_string_float64_array -func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_email_array +func (s *Server) handleTestResponseStringEmailArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float64_array"), + otelogen.OperationID("test_response_string_email_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float64_array"), + semconv.HTTPRouteKey.String("/test_response_string_email_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89319,11 +89328,11 @@ func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat64Array", - ID: "test_response_string_float64_array", + Name: "TestResponseStringEmailArray", + ID: "test_response_string_email_array", } ) - request, close, err := s.decodeTestResponseStringFloat64ArrayRequest(r) + request, close, err := s.decodeTestResponseStringEmailArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89339,13 +89348,13 @@ func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, arg } }() - var response []float64 + var response []string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat64Array", + OperationName: "TestResponseStringEmailArray", OperationSummary: "", - OperationID: "test_response_string_float64_array", + OperationID: "test_response_string_email_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89354,7 +89363,7 @@ func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = []float64 + Response = []string ) response, err = middleware.HookMiddleware[ Request, @@ -89365,12 +89374,12 @@ func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat64Array(ctx, request) + response, err = s.h.TestResponseStringEmailArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat64Array(ctx, request) + response, err = s.h.TestResponseStringEmailArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -89378,7 +89387,7 @@ func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, arg return } - if err := encodeTestResponseStringFloat64ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringEmailArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89387,18 +89396,18 @@ func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, arg } } -// handleTestResponseStringFloat64ArrayArrayRequest handles test_response_string_float64_array_array operation. +// handleTestResponseStringEmailArrayArrayRequest handles test_response_string_email_array_array operation. // -// POST /test_response_string_float64_array_array -func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_email_array_array +func (s *Server) handleTestResponseStringEmailArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float64_array_array"), + otelogen.OperationID("test_response_string_email_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float64_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_email_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89423,11 +89432,11 @@ func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat64ArrayArray", - ID: "test_response_string_float64_array_array", + Name: "TestResponseStringEmailArrayArray", + ID: "test_response_string_email_array_array", } ) - request, close, err := s.decodeTestResponseStringFloat64ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringEmailArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89443,13 +89452,13 @@ func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string } }() - var response [][]float64 + var response [][]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat64ArrayArray", + OperationName: "TestResponseStringEmailArrayArray", OperationSummary: "", - OperationID: "test_response_string_float64_array_array", + OperationID: "test_response_string_email_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89458,7 +89467,7 @@ func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = [][]float64 + Response = [][]string ) response, err = middleware.HookMiddleware[ Request, @@ -89469,12 +89478,12 @@ func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat64ArrayArray(ctx, request) + response, err = s.h.TestResponseStringEmailArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat64ArrayArray(ctx, request) + response, err = s.h.TestResponseStringEmailArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -89482,7 +89491,7 @@ func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string return } - if err := encodeTestResponseStringFloat64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringEmailArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89491,18 +89500,18 @@ func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string } } -// handleTestResponseStringFloat64NullableRequest handles test_response_string_float64_nullable operation. +// handleTestResponseStringEmailNullableRequest handles test_response_string_email_nullable operation. // -// POST /test_response_string_float64_nullable -func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_email_nullable +func (s *Server) handleTestResponseStringEmailNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float64_nullable"), + otelogen.OperationID("test_response_string_email_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float64_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_email_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89527,11 +89536,11 @@ func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat64Nullable", - ID: "test_response_string_float64_nullable", + Name: "TestResponseStringEmailNullable", + ID: "test_response_string_email_nullable", } ) - request, close, err := s.decodeTestResponseStringFloat64NullableRequest(r) + request, close, err := s.decodeTestResponseStringEmailNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89547,13 +89556,13 @@ func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, } }() - var response NilStringFloat64 + var response NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat64Nullable", + OperationName: "TestResponseStringEmailNullable", OperationSummary: "", - OperationID: "test_response_string_float64_nullable", + OperationID: "test_response_string_email_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89562,7 +89571,7 @@ func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilStringFloat64 + Response = NilString ) response, err = middleware.HookMiddleware[ Request, @@ -89573,12 +89582,12 @@ func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat64Nullable(ctx, request) + response, err = s.h.TestResponseStringEmailNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat64Nullable(ctx, request) + response, err = s.h.TestResponseStringEmailNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -89586,7 +89595,7 @@ func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, return } - if err := encodeTestResponseStringFloat64NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringEmailNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89595,18 +89604,18 @@ func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, } } -// handleTestResponseStringFloat64NullableArrayRequest handles test_response_string_float64_nullable_array operation. +// handleTestResponseStringEmailNullableArrayRequest handles test_response_string_email_nullable_array operation. // -// POST /test_response_string_float64_nullable_array -func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_email_nullable_array +func (s *Server) handleTestResponseStringEmailNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float64_nullable_array"), + otelogen.OperationID("test_response_string_email_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float64_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_email_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89631,11 +89640,11 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat64NullableArray", - ID: "test_response_string_float64_nullable_array", + Name: "TestResponseStringEmailNullableArray", + ID: "test_response_string_email_nullable_array", } ) - request, close, err := s.decodeTestResponseStringFloat64NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringEmailNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89651,13 +89660,13 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]str } }() - var response []NilStringFloat64 + var response []NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat64NullableArray", + OperationName: "TestResponseStringEmailNullableArray", OperationSummary: "", - OperationID: "test_response_string_float64_nullable_array", + OperationID: "test_response_string_email_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89666,7 +89675,7 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = []NilStringFloat64 + Response = []NilString ) response, err = middleware.HookMiddleware[ Request, @@ -89677,12 +89686,12 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat64NullableArray(ctx, request) + response, err = s.h.TestResponseStringEmailNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat64NullableArray(ctx, request) + response, err = s.h.TestResponseStringEmailNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -89690,7 +89699,7 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]str return } - if err := encodeTestResponseStringFloat64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringEmailNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89699,18 +89708,18 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]str } } -// handleTestResponseStringFloat64NullableArrayArrayRequest handles test_response_string_float64_nullable_array_array operation. +// handleTestResponseStringEmailNullableArrayArrayRequest handles test_response_string_email_nullable_array_array operation. // -// POST /test_response_string_float64_nullable_array_array -func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_email_nullable_array_array +func (s *Server) handleTestResponseStringEmailNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_float64_nullable_array_array"), + otelogen.OperationID("test_response_string_email_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_float64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_email_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringEmailNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89735,11 +89744,11 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [ } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringFloat64NullableArrayArray", - ID: "test_response_string_float64_nullable_array_array", + Name: "TestResponseStringEmailNullableArrayArray", + ID: "test_response_string_email_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringFloat64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringEmailNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89755,13 +89764,13 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [ } }() - var response [][]NilStringFloat64 + var response [][]NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringFloat64NullableArrayArray", + OperationName: "TestResponseStringEmailNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_float64_nullable_array_array", + OperationID: "test_response_string_email_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89770,7 +89779,7 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [ type ( Request = string Params = struct{} - Response = [][]NilStringFloat64 + Response = [][]NilString ) response, err = middleware.HookMiddleware[ Request, @@ -89781,12 +89790,12 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [ mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringFloat64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringEmailNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringFloat64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringEmailNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -89794,7 +89803,7 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [ return } - if err := encodeTestResponseStringFloat64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringEmailNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89803,18 +89812,18 @@ func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [ } } -// handleTestResponseStringHostnameRequest handles test_response_string_hostname operation. +// handleTestResponseStringFloat32Request handles test_response_string_float32 operation. // -// POST /test_response_string_hostname -func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float32 +func (s *Server) handleTestResponseStringFloat32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_hostname"), + otelogen.OperationID("test_response_string_float32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_hostname"), + semconv.HTTPRouteKey.String("/test_response_string_float32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostname", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89839,11 +89848,11 @@ func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringHostname", - ID: "test_response_string_hostname", + Name: "TestResponseStringFloat32", + ID: "test_response_string_float32", } ) - request, close, err := s.decodeTestResponseStringHostnameRequest(r) + request, close, err := s.decodeTestResponseStringFloat32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89859,13 +89868,13 @@ func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEsc } }() - var response string + var response float32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringHostname", + OperationName: "TestResponseStringFloat32", OperationSummary: "", - OperationID: "test_response_string_hostname", + OperationID: "test_response_string_float32", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89874,7 +89883,7 @@ func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEsc type ( Request = string Params = struct{} - Response = string + Response = float32 ) response, err = middleware.HookMiddleware[ Request, @@ -89885,12 +89894,12 @@ func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringHostname(ctx, request) + response, err = s.h.TestResponseStringFloat32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringHostname(ctx, request) + response, err = s.h.TestResponseStringFloat32(ctx, request) } if err != nil { recordError("Internal", err) @@ -89898,7 +89907,7 @@ func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEsc return } - if err := encodeTestResponseStringHostnameResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -89907,18 +89916,18 @@ func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEsc } } -// handleTestResponseStringHostnameArrayRequest handles test_response_string_hostname_array operation. +// handleTestResponseStringFloat32ArrayRequest handles test_response_string_float32_array operation. // -// POST /test_response_string_hostname_array -func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float32_array +func (s *Server) handleTestResponseStringFloat32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_hostname_array"), + otelogen.OperationID("test_response_string_float32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_hostname_array"), + semconv.HTTPRouteKey.String("/test_response_string_float32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -89943,11 +89952,11 @@ func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringHostnameArray", - ID: "test_response_string_hostname_array", + Name: "TestResponseStringFloat32Array", + ID: "test_response_string_float32_array", } ) - request, close, err := s.decodeTestResponseStringHostnameArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -89963,13 +89972,13 @@ func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, ar } }() - var response []string + var response []float32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringHostnameArray", + OperationName: "TestResponseStringFloat32Array", OperationSummary: "", - OperationID: "test_response_string_hostname_array", + OperationID: "test_response_string_float32_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -89978,7 +89987,7 @@ func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = []string + Response = []float32 ) response, err = middleware.HookMiddleware[ Request, @@ -89989,12 +89998,12 @@ func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringHostnameArray(ctx, request) + response, err = s.h.TestResponseStringFloat32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringHostnameArray(ctx, request) + response, err = s.h.TestResponseStringFloat32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -90002,7 +90011,7 @@ func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, ar return } - if err := encodeTestResponseStringHostnameArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90011,18 +90020,18 @@ func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, ar } } -// handleTestResponseStringHostnameArrayArrayRequest handles test_response_string_hostname_array_array operation. +// handleTestResponseStringFloat32ArrayArrayRequest handles test_response_string_float32_array_array operation. // -// POST /test_response_string_hostname_array_array -func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float32_array_array +func (s *Server) handleTestResponseStringFloat32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_hostname_array_array"), + otelogen.OperationID("test_response_string_float32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_hostname_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_float32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90047,11 +90056,11 @@ func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringHostnameArrayArray", - ID: "test_response_string_hostname_array_array", + Name: "TestResponseStringFloat32ArrayArray", + ID: "test_response_string_float32_array_array", } ) - request, close, err := s.decodeTestResponseStringHostnameArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90067,13 +90076,13 @@ func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]strin } }() - var response [][]string + var response [][]float32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringHostnameArrayArray", + OperationName: "TestResponseStringFloat32ArrayArray", OperationSummary: "", - OperationID: "test_response_string_hostname_array_array", + OperationID: "test_response_string_float32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90082,7 +90091,7 @@ func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = [][]string + Response = [][]float32 ) response, err = middleware.HookMiddleware[ Request, @@ -90093,12 +90102,12 @@ func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringHostnameArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringHostnameArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -90106,7 +90115,7 @@ func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]strin return } - if err := encodeTestResponseStringHostnameArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90115,18 +90124,18 @@ func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]strin } } -// handleTestResponseStringHostnameNullableRequest handles test_response_string_hostname_nullable operation. +// handleTestResponseStringFloat32NullableRequest handles test_response_string_float32_nullable operation. // -// POST /test_response_string_hostname_nullable -func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float32_nullable +func (s *Server) handleTestResponseStringFloat32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_hostname_nullable"), + otelogen.OperationID("test_response_string_float32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_hostname_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_float32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90151,11 +90160,11 @@ func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringHostnameNullable", - ID: "test_response_string_hostname_nullable", + Name: "TestResponseStringFloat32Nullable", + ID: "test_response_string_float32_nullable", } ) - request, close, err := s.decodeTestResponseStringHostnameNullableRequest(r) + request, close, err := s.decodeTestResponseStringFloat32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90171,13 +90180,13 @@ func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, } }() - var response NilString + var response NilStringFloat32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringHostnameNullable", + OperationName: "TestResponseStringFloat32Nullable", OperationSummary: "", - OperationID: "test_response_string_hostname_nullable", + OperationID: "test_response_string_float32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90186,7 +90195,7 @@ func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, type ( Request = string Params = struct{} - Response = NilString + Response = NilStringFloat32 ) response, err = middleware.HookMiddleware[ Request, @@ -90197,12 +90206,12 @@ func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringHostnameNullable(ctx, request) + response, err = s.h.TestResponseStringFloat32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringHostnameNullable(ctx, request) + response, err = s.h.TestResponseStringFloat32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -90210,7 +90219,7 @@ func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, return } - if err := encodeTestResponseStringHostnameNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90219,18 +90228,18 @@ func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, } } -// handleTestResponseStringHostnameNullableArrayRequest handles test_response_string_hostname_nullable_array operation. +// handleTestResponseStringFloat32NullableArrayRequest handles test_response_string_float32_nullable_array operation. // -// POST /test_response_string_hostname_nullable_array -func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float32_nullable_array +func (s *Server) handleTestResponseStringFloat32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_hostname_nullable_array"), + otelogen.OperationID("test_response_string_float32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_hostname_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_float32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90255,11 +90264,11 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringHostnameNullableArray", - ID: "test_response_string_hostname_nullable_array", + Name: "TestResponseStringFloat32NullableArray", + ID: "test_response_string_float32_nullable_array", } ) - request, close, err := s.decodeTestResponseStringHostnameNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90275,13 +90284,13 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]st } }() - var response []NilString + var response []NilStringFloat32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringHostnameNullableArray", + OperationName: "TestResponseStringFloat32NullableArray", OperationSummary: "", - OperationID: "test_response_string_hostname_nullable_array", + OperationID: "test_response_string_float32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90290,7 +90299,7 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]st type ( Request = string Params = struct{} - Response = []NilString + Response = []NilStringFloat32 ) response, err = middleware.HookMiddleware[ Request, @@ -90301,12 +90310,12 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringHostnameNullableArray(ctx, request) + response, err = s.h.TestResponseStringFloat32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringHostnameNullableArray(ctx, request) + response, err = s.h.TestResponseStringFloat32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -90314,7 +90323,7 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]st return } - if err := encodeTestResponseStringHostnameNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90323,18 +90332,18 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]st } } -// handleTestResponseStringHostnameNullableArrayArrayRequest handles test_response_string_hostname_nullable_array_array operation. +// handleTestResponseStringFloat32NullableArrayArrayRequest handles test_response_string_float32_nullable_array_array operation. // -// POST /test_response_string_hostname_nullable_array_array -func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float32_nullable_array_array +func (s *Server) handleTestResponseStringFloat32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_hostname_nullable_array_array"), + otelogen.OperationID("test_response_string_float32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_hostname_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_float32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90359,11 +90368,11 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringHostnameNullableArrayArray", - ID: "test_response_string_hostname_nullable_array_array", + Name: "TestResponseStringFloat32NullableArrayArray", + ID: "test_response_string_float32_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringHostnameNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90379,13 +90388,13 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args } }() - var response [][]NilString + var response [][]NilStringFloat32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringHostnameNullableArrayArray", + OperationName: "TestResponseStringFloat32NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_hostname_nullable_array_array", + OperationID: "test_response_string_float32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90394,7 +90403,7 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args type ( Request = string Params = struct{} - Response = [][]NilString + Response = [][]NilStringFloat32 ) response, err = middleware.HookMiddleware[ Request, @@ -90405,12 +90414,12 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringHostnameNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringHostnameNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -90418,7 +90427,7 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args return } - if err := encodeTestResponseStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90427,18 +90436,18 @@ func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args } } -// handleTestResponseStringIPRequest handles test_response_string_ip operation. +// handleTestResponseStringFloat64Request handles test_response_string_float64 operation. // -// POST /test_response_string_ip -func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float64 +func (s *Server) handleTestResponseStringFloat64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ip"), + otelogen.OperationID("test_response_string_float64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ip"), + semconv.HTTPRouteKey.String("/test_response_string_float64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIP", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90463,11 +90472,11 @@ func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped b } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIP", - ID: "test_response_string_ip", + Name: "TestResponseStringFloat64", + ID: "test_response_string_float64", } ) - request, close, err := s.decodeTestResponseStringIPRequest(r) + request, close, err := s.decodeTestResponseStringFloat64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90483,13 +90492,13 @@ func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped b } }() - var response netip.Addr + var response float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIP", + OperationName: "TestResponseStringFloat64", OperationSummary: "", - OperationID: "test_response_string_ip", + OperationID: "test_response_string_float64", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90498,7 +90507,7 @@ func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped b type ( Request = string Params = struct{} - Response = netip.Addr + Response = float64 ) response, err = middleware.HookMiddleware[ Request, @@ -90509,12 +90518,12 @@ func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped b mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIP(ctx, request) + response, err = s.h.TestResponseStringFloat64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIP(ctx, request) + response, err = s.h.TestResponseStringFloat64(ctx, request) } if err != nil { recordError("Internal", err) @@ -90522,7 +90531,7 @@ func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped b return } - if err := encodeTestResponseStringIPResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90531,18 +90540,18 @@ func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped b } } -// handleTestResponseStringIPArrayRequest handles test_response_string_ip_array operation. +// handleTestResponseStringFloat64ArrayRequest handles test_response_string_float64_array operation. // -// POST /test_response_string_ip_array -func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float64_array +func (s *Server) handleTestResponseStringFloat64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ip_array"), + otelogen.OperationID("test_response_string_float64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ip_array"), + semconv.HTTPRouteKey.String("/test_response_string_float64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90567,11 +90576,11 @@ func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEsca } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIPArray", - ID: "test_response_string_ip_array", + Name: "TestResponseStringFloat64Array", + ID: "test_response_string_float64_array", } ) - request, close, err := s.decodeTestResponseStringIPArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90587,13 +90596,13 @@ func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEsca } }() - var response []netip.Addr + var response []float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIPArray", + OperationName: "TestResponseStringFloat64Array", OperationSummary: "", - OperationID: "test_response_string_ip_array", + OperationID: "test_response_string_float64_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90602,7 +90611,7 @@ func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEsca type ( Request = string Params = struct{} - Response = []netip.Addr + Response = []float64 ) response, err = middleware.HookMiddleware[ Request, @@ -90613,12 +90622,12 @@ func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEsca mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIPArray(ctx, request) + response, err = s.h.TestResponseStringFloat64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIPArray(ctx, request) + response, err = s.h.TestResponseStringFloat64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -90626,7 +90635,7 @@ func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEsca return } - if err := encodeTestResponseStringIPArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90635,18 +90644,18 @@ func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEsca } } -// handleTestResponseStringIPArrayArrayRequest handles test_response_string_ip_array_array operation. +// handleTestResponseStringFloat64ArrayArrayRequest handles test_response_string_float64_array_array operation. // -// POST /test_response_string_ip_array_array -func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float64_array_array +func (s *Server) handleTestResponseStringFloat64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ip_array_array"), + otelogen.OperationID("test_response_string_float64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ip_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_float64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90671,11 +90680,11 @@ func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIPArrayArray", - ID: "test_response_string_ip_array_array", + Name: "TestResponseStringFloat64ArrayArray", + ID: "test_response_string_float64_array_array", } ) - request, close, err := s.decodeTestResponseStringIPArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90691,13 +90700,13 @@ func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, arg } }() - var response [][]netip.Addr + var response [][]float64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIPArrayArray", + OperationName: "TestResponseStringFloat64ArrayArray", OperationSummary: "", - OperationID: "test_response_string_ip_array_array", + OperationID: "test_response_string_float64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90706,7 +90715,7 @@ func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = [][]netip.Addr + Response = [][]float64 ) response, err = middleware.HookMiddleware[ Request, @@ -90717,12 +90726,12 @@ func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIPArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIPArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -90730,7 +90739,7 @@ func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, arg return } - if err := encodeTestResponseStringIPArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90739,18 +90748,18 @@ func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, arg } } -// handleTestResponseStringIPNullableRequest handles test_response_string_ip_nullable operation. +// handleTestResponseStringFloat64NullableRequest handles test_response_string_float64_nullable operation. // -// POST /test_response_string_ip_nullable -func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float64_nullable +func (s *Server) handleTestResponseStringFloat64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ip_nullable"), + otelogen.OperationID("test_response_string_float64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ip_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_float64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90775,11 +90784,11 @@ func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIPNullable", - ID: "test_response_string_ip_nullable", + Name: "TestResponseStringFloat64Nullable", + ID: "test_response_string_float64_nullable", } ) - request, close, err := s.decodeTestResponseStringIPNullableRequest(r) + request, close, err := s.decodeTestResponseStringFloat64NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90795,13 +90804,13 @@ func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsE } }() - var response NilIP + var response NilStringFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIPNullable", + OperationName: "TestResponseStringFloat64Nullable", OperationSummary: "", - OperationID: "test_response_string_ip_nullable", + OperationID: "test_response_string_float64_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90810,7 +90819,7 @@ func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = NilIP + Response = NilStringFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -90821,12 +90830,12 @@ func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIPNullable(ctx, request) + response, err = s.h.TestResponseStringFloat64Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIPNullable(ctx, request) + response, err = s.h.TestResponseStringFloat64Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -90834,7 +90843,7 @@ func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsE return } - if err := encodeTestResponseStringIPNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat64NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90843,18 +90852,18 @@ func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsE } } -// handleTestResponseStringIPNullableArrayRequest handles test_response_string_ip_nullable_array operation. +// handleTestResponseStringFloat64NullableArrayRequest handles test_response_string_float64_nullable_array operation. // -// POST /test_response_string_ip_nullable_array -func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float64_nullable_array +func (s *Server) handleTestResponseStringFloat64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ip_nullable_array"), + otelogen.OperationID("test_response_string_float64_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ip_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_float64_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90879,11 +90888,11 @@ func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIPNullableArray", - ID: "test_response_string_ip_nullable_array", + Name: "TestResponseStringFloat64NullableArray", + ID: "test_response_string_float64_nullable_array", } ) - request, close, err := s.decodeTestResponseStringIPNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat64NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -90899,13 +90908,13 @@ func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, } }() - var response []NilIP + var response []NilStringFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIPNullableArray", + OperationName: "TestResponseStringFloat64NullableArray", OperationSummary: "", - OperationID: "test_response_string_ip_nullable_array", + OperationID: "test_response_string_float64_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -90914,7 +90923,7 @@ func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = []NilIP + Response = []NilStringFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -90925,12 +90934,12 @@ func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIPNullableArray(ctx, request) + response, err = s.h.TestResponseStringFloat64NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIPNullableArray(ctx, request) + response, err = s.h.TestResponseStringFloat64NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -90938,7 +90947,7 @@ func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, return } - if err := encodeTestResponseStringIPNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat64NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -90947,18 +90956,18 @@ func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, } } -// handleTestResponseStringIPNullableArrayArrayRequest handles test_response_string_ip_nullable_array_array operation. +// handleTestResponseStringFloat64NullableArrayArrayRequest handles test_response_string_float64_nullable_array_array operation. // -// POST /test_response_string_ip_nullable_array_array -func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_float64_nullable_array_array +func (s *Server) handleTestResponseStringFloat64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ip_nullable_array_array"), + otelogen.OperationID("test_response_string_float64_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ip_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_float64_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringFloat64NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -90983,11 +90992,11 @@ func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]str } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIPNullableArrayArray", - ID: "test_response_string_ip_nullable_array_array", + Name: "TestResponseStringFloat64NullableArrayArray", + ID: "test_response_string_float64_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringIPNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringFloat64NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91003,13 +91012,13 @@ func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]str } }() - var response [][]NilIP + var response [][]NilStringFloat64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIPNullableArrayArray", + OperationName: "TestResponseStringFloat64NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_ip_nullable_array_array", + OperationID: "test_response_string_float64_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91018,7 +91027,7 @@ func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]str type ( Request = string Params = struct{} - Response = [][]NilIP + Response = [][]NilStringFloat64 ) response, err = middleware.HookMiddleware[ Request, @@ -91029,12 +91038,12 @@ func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]str mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIPNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat64NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIPNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringFloat64NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -91042,7 +91051,7 @@ func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]str return } - if err := encodeTestResponseStringIPNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringFloat64NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91051,18 +91060,18 @@ func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]str } } -// handleTestResponseStringIntRequest handles test_response_string_int operation. +// handleTestResponseStringHostnameRequest handles test_response_string_hostname operation. // -// POST /test_response_string_int -func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_hostname +func (s *Server) handleTestResponseStringHostnameRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int"), + otelogen.OperationID("test_response_string_hostname"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int"), + semconv.HTTPRouteKey.String("/test_response_string_hostname"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostname", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91087,11 +91096,11 @@ func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt", - ID: "test_response_string_int", + Name: "TestResponseStringHostname", + ID: "test_response_string_hostname", } ) - request, close, err := s.decodeTestResponseStringIntRequest(r) + request, close, err := s.decodeTestResponseStringHostnameRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91107,13 +91116,13 @@ func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped } }() - var response int + var response string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt", + OperationName: "TestResponseStringHostname", OperationSummary: "", - OperationID: "test_response_string_int", + OperationID: "test_response_string_hostname", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91122,7 +91131,7 @@ func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped type ( Request = string Params = struct{} - Response = int + Response = string ) response, err = middleware.HookMiddleware[ Request, @@ -91133,12 +91142,12 @@ func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt(ctx, request) + response, err = s.h.TestResponseStringHostname(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt(ctx, request) + response, err = s.h.TestResponseStringHostname(ctx, request) } if err != nil { recordError("Internal", err) @@ -91146,7 +91155,7 @@ func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped return } - if err := encodeTestResponseStringIntResponse(response, w, span); err != nil { + if err := encodeTestResponseStringHostnameResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91155,18 +91164,18 @@ func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped } } -// handleTestResponseStringInt16Request handles test_response_string_int16 operation. +// handleTestResponseStringHostnameArrayRequest handles test_response_string_hostname_array operation. // -// POST /test_response_string_int16 -func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_hostname_array +func (s *Server) handleTestResponseStringHostnameArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int16"), + otelogen.OperationID("test_response_string_hostname_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int16"), + semconv.HTTPRouteKey.String("/test_response_string_hostname_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91191,11 +91200,11 @@ func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt16", - ID: "test_response_string_int16", + Name: "TestResponseStringHostnameArray", + ID: "test_response_string_hostname_array", } ) - request, close, err := s.decodeTestResponseStringInt16Request(r) + request, close, err := s.decodeTestResponseStringHostnameArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91211,13 +91220,13 @@ func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscape } }() - var response int16 + var response []string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt16", + OperationName: "TestResponseStringHostnameArray", OperationSummary: "", - OperationID: "test_response_string_int16", + OperationID: "test_response_string_hostname_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91226,7 +91235,7 @@ func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = int16 + Response = []string ) response, err = middleware.HookMiddleware[ Request, @@ -91237,12 +91246,12 @@ func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt16(ctx, request) + response, err = s.h.TestResponseStringHostnameArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt16(ctx, request) + response, err = s.h.TestResponseStringHostnameArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -91250,7 +91259,7 @@ func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscape return } - if err := encodeTestResponseStringInt16Response(response, w, span); err != nil { + if err := encodeTestResponseStringHostnameArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91259,18 +91268,18 @@ func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscape } } -// handleTestResponseStringInt16ArrayRequest handles test_response_string_int16_array operation. +// handleTestResponseStringHostnameArrayArrayRequest handles test_response_string_hostname_array_array operation. // -// POST /test_response_string_int16_array -func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_hostname_array_array +func (s *Server) handleTestResponseStringHostnameArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int16_array"), + otelogen.OperationID("test_response_string_hostname_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int16_array"), + semconv.HTTPRouteKey.String("/test_response_string_hostname_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91295,11 +91304,11 @@ func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt16Array", - ID: "test_response_string_int16_array", + Name: "TestResponseStringHostnameArrayArray", + ID: "test_response_string_hostname_array_array", } ) - request, close, err := s.decodeTestResponseStringInt16ArrayRequest(r) + request, close, err := s.decodeTestResponseStringHostnameArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91315,13 +91324,13 @@ func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsE } }() - var response []int16 + var response [][]string if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt16Array", + OperationName: "TestResponseStringHostnameArrayArray", OperationSummary: "", - OperationID: "test_response_string_int16_array", + OperationID: "test_response_string_hostname_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91330,7 +91339,7 @@ func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []int16 + Response = [][]string ) response, err = middleware.HookMiddleware[ Request, @@ -91341,12 +91350,12 @@ func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt16Array(ctx, request) + response, err = s.h.TestResponseStringHostnameArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt16Array(ctx, request) + response, err = s.h.TestResponseStringHostnameArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -91354,7 +91363,7 @@ func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseStringInt16ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringHostnameArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91363,18 +91372,18 @@ func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsE } } -// handleTestResponseStringInt16ArrayArrayRequest handles test_response_string_int16_array_array operation. +// handleTestResponseStringHostnameNullableRequest handles test_response_string_hostname_nullable operation. // -// POST /test_response_string_int16_array_array -func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_hostname_nullable +func (s *Server) handleTestResponseStringHostnameNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int16_array_array"), + otelogen.OperationID("test_response_string_hostname_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int16_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_hostname_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91399,11 +91408,11 @@ func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt16ArrayArray", - ID: "test_response_string_int16_array_array", + Name: "TestResponseStringHostnameNullable", + ID: "test_response_string_hostname_nullable", } ) - request, close, err := s.decodeTestResponseStringInt16ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringHostnameNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91419,13 +91428,13 @@ func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, } }() - var response [][]int16 + var response NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt16ArrayArray", + OperationName: "TestResponseStringHostnameNullable", OperationSummary: "", - OperationID: "test_response_string_int16_array_array", + OperationID: "test_response_string_hostname_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91434,7 +91443,7 @@ func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int16 + Response = NilString ) response, err = middleware.HookMiddleware[ Request, @@ -91445,12 +91454,12 @@ func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt16ArrayArray(ctx, request) + response, err = s.h.TestResponseStringHostnameNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt16ArrayArray(ctx, request) + response, err = s.h.TestResponseStringHostnameNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -91458,7 +91467,7 @@ func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseStringInt16ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringHostnameNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91467,18 +91476,18 @@ func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, } } -// handleTestResponseStringInt16NullableRequest handles test_response_string_int16_nullable operation. +// handleTestResponseStringHostnameNullableArrayRequest handles test_response_string_hostname_nullable_array operation. // -// POST /test_response_string_int16_nullable -func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_hostname_nullable_array +func (s *Server) handleTestResponseStringHostnameNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int16_nullable"), + otelogen.OperationID("test_response_string_hostname_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int16_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_hostname_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91503,11 +91512,11 @@ func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt16Nullable", - ID: "test_response_string_int16_nullable", + Name: "TestResponseStringHostnameNullableArray", + ID: "test_response_string_hostname_nullable_array", } ) - request, close, err := s.decodeTestResponseStringInt16NullableRequest(r) + request, close, err := s.decodeTestResponseStringHostnameNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91523,13 +91532,13 @@ func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, ar } }() - var response NilStringInt16 + var response []NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt16Nullable", + OperationName: "TestResponseStringHostnameNullableArray", OperationSummary: "", - OperationID: "test_response_string_int16_nullable", + OperationID: "test_response_string_hostname_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91538,7 +91547,7 @@ func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilStringInt16 + Response = []NilString ) response, err = middleware.HookMiddleware[ Request, @@ -91549,12 +91558,12 @@ func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt16Nullable(ctx, request) + response, err = s.h.TestResponseStringHostnameNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt16Nullable(ctx, request) + response, err = s.h.TestResponseStringHostnameNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -91562,7 +91571,7 @@ func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, ar return } - if err := encodeTestResponseStringInt16NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringHostnameNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91571,18 +91580,18 @@ func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, ar } } -// handleTestResponseStringInt16NullableArrayRequest handles test_response_string_int16_nullable_array operation. +// handleTestResponseStringHostnameNullableArrayArrayRequest handles test_response_string_hostname_nullable_array_array operation. // -// POST /test_response_string_int16_nullable_array -func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_hostname_nullable_array_array +func (s *Server) handleTestResponseStringHostnameNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int16_nullable_array"), + otelogen.OperationID("test_response_string_hostname_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int16_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_hostname_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringHostnameNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91607,11 +91616,11 @@ func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt16NullableArray", - ID: "test_response_string_int16_nullable_array", + Name: "TestResponseStringHostnameNullableArrayArray", + ID: "test_response_string_hostname_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringInt16NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringHostnameNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91627,13 +91636,13 @@ func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]strin } }() - var response []NilStringInt16 + var response [][]NilString if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt16NullableArray", + OperationName: "TestResponseStringHostnameNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_int16_nullable_array", + OperationID: "test_response_string_hostname_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91642,7 +91651,7 @@ func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilStringInt16 + Response = [][]NilString ) response, err = middleware.HookMiddleware[ Request, @@ -91653,12 +91662,12 @@ func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt16NullableArray(ctx, request) + response, err = s.h.TestResponseStringHostnameNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt16NullableArray(ctx, request) + response, err = s.h.TestResponseStringHostnameNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -91666,7 +91675,7 @@ func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]strin return } - if err := encodeTestResponseStringInt16NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringHostnameNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91675,18 +91684,18 @@ func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]strin } } -// handleTestResponseStringInt16NullableArrayArrayRequest handles test_response_string_int16_nullable_array_array operation. +// handleTestResponseStringIPRequest handles test_response_string_ip operation. // -// POST /test_response_string_int16_nullable_array_array -func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ip +func (s *Server) handleTestResponseStringIPRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int16_nullable_array_array"), + otelogen.OperationID("test_response_string_ip"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int16_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_ip"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIP", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91711,11 +91720,11 @@ func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt16NullableArrayArray", - ID: "test_response_string_int16_nullable_array_array", + Name: "TestResponseStringIP", + ID: "test_response_string_ip", } ) - request, close, err := s.decodeTestResponseStringInt16NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringIPRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91731,13 +91740,13 @@ func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0] } }() - var response [][]NilStringInt16 + var response netip.Addr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt16NullableArrayArray", + OperationName: "TestResponseStringIP", OperationSummary: "", - OperationID: "test_response_string_int16_nullable_array_array", + OperationID: "test_response_string_ip", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91746,7 +91755,7 @@ func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilStringInt16 + Response = netip.Addr ) response, err = middleware.HookMiddleware[ Request, @@ -91757,12 +91766,12 @@ func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt16NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringIP(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt16NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringIP(ctx, request) } if err != nil { recordError("Internal", err) @@ -91770,7 +91779,7 @@ func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseStringInt16NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIPResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91779,18 +91788,18 @@ func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0] } } -// handleTestResponseStringInt32Request handles test_response_string_int32 operation. +// handleTestResponseStringIPArrayRequest handles test_response_string_ip_array operation. // -// POST /test_response_string_int32 -func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ip_array +func (s *Server) handleTestResponseStringIPArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int32"), + otelogen.OperationID("test_response_string_ip_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int32"), + semconv.HTTPRouteKey.String("/test_response_string_ip_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91815,11 +91824,11 @@ func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt32", - ID: "test_response_string_int32", + Name: "TestResponseStringIPArray", + ID: "test_response_string_ip_array", } ) - request, close, err := s.decodeTestResponseStringInt32Request(r) + request, close, err := s.decodeTestResponseStringIPArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91835,13 +91844,13 @@ func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscape } }() - var response int32 + var response []netip.Addr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt32", + OperationName: "TestResponseStringIPArray", OperationSummary: "", - OperationID: "test_response_string_int32", + OperationID: "test_response_string_ip_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91850,7 +91859,7 @@ func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = int32 + Response = []netip.Addr ) response, err = middleware.HookMiddleware[ Request, @@ -91861,12 +91870,12 @@ func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt32(ctx, request) + response, err = s.h.TestResponseStringIPArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt32(ctx, request) + response, err = s.h.TestResponseStringIPArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -91874,7 +91883,7 @@ func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscape return } - if err := encodeTestResponseStringInt32Response(response, w, span); err != nil { + if err := encodeTestResponseStringIPArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91883,18 +91892,18 @@ func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscape } } -// handleTestResponseStringInt32ArrayRequest handles test_response_string_int32_array operation. +// handleTestResponseStringIPArrayArrayRequest handles test_response_string_ip_array_array operation. // -// POST /test_response_string_int32_array -func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ip_array_array +func (s *Server) handleTestResponseStringIPArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int32_array"), + otelogen.OperationID("test_response_string_ip_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int32_array"), + semconv.HTTPRouteKey.String("/test_response_string_ip_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -91919,11 +91928,11 @@ func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt32Array", - ID: "test_response_string_int32_array", + Name: "TestResponseStringIPArrayArray", + ID: "test_response_string_ip_array_array", } ) - request, close, err := s.decodeTestResponseStringInt32ArrayRequest(r) + request, close, err := s.decodeTestResponseStringIPArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -91939,13 +91948,13 @@ func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsE } }() - var response []int32 + var response [][]netip.Addr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt32Array", + OperationName: "TestResponseStringIPArrayArray", OperationSummary: "", - OperationID: "test_response_string_int32_array", + OperationID: "test_response_string_ip_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -91954,7 +91963,7 @@ func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []int32 + Response = [][]netip.Addr ) response, err = middleware.HookMiddleware[ Request, @@ -91965,12 +91974,12 @@ func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt32Array(ctx, request) + response, err = s.h.TestResponseStringIPArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt32Array(ctx, request) + response, err = s.h.TestResponseStringIPArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -91978,7 +91987,7 @@ func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseStringInt32ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIPArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -91987,18 +91996,18 @@ func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsE } } -// handleTestResponseStringInt32ArrayArrayRequest handles test_response_string_int32_array_array operation. +// handleTestResponseStringIPNullableRequest handles test_response_string_ip_nullable operation. // -// POST /test_response_string_int32_array_array -func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ip_nullable +func (s *Server) handleTestResponseStringIPNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int32_array_array"), + otelogen.OperationID("test_response_string_ip_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int32_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_ip_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92023,11 +92032,11 @@ func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt32ArrayArray", - ID: "test_response_string_int32_array_array", + Name: "TestResponseStringIPNullable", + ID: "test_response_string_ip_nullable", } ) - request, close, err := s.decodeTestResponseStringInt32ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringIPNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92043,13 +92052,13 @@ func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, } }() - var response [][]int32 + var response NilIP if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt32ArrayArray", + OperationName: "TestResponseStringIPNullable", OperationSummary: "", - OperationID: "test_response_string_int32_array_array", + OperationID: "test_response_string_ip_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92058,7 +92067,7 @@ func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int32 + Response = NilIP ) response, err = middleware.HookMiddleware[ Request, @@ -92069,12 +92078,12 @@ func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt32ArrayArray(ctx, request) + response, err = s.h.TestResponseStringIPNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt32ArrayArray(ctx, request) + response, err = s.h.TestResponseStringIPNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -92082,7 +92091,7 @@ func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseStringInt32ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIPNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92091,18 +92100,18 @@ func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, } } -// handleTestResponseStringInt32NullableRequest handles test_response_string_int32_nullable operation. +// handleTestResponseStringIPNullableArrayRequest handles test_response_string_ip_nullable_array operation. // -// POST /test_response_string_int32_nullable -func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ip_nullable_array +func (s *Server) handleTestResponseStringIPNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int32_nullable"), + otelogen.OperationID("test_response_string_ip_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int32_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_ip_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92127,11 +92136,11 @@ func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt32Nullable", - ID: "test_response_string_int32_nullable", + Name: "TestResponseStringIPNullableArray", + ID: "test_response_string_ip_nullable_array", } ) - request, close, err := s.decodeTestResponseStringInt32NullableRequest(r) + request, close, err := s.decodeTestResponseStringIPNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92147,13 +92156,13 @@ func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, ar } }() - var response NilStringInt32 + var response []NilIP if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt32Nullable", + OperationName: "TestResponseStringIPNullableArray", OperationSummary: "", - OperationID: "test_response_string_int32_nullable", + OperationID: "test_response_string_ip_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92162,7 +92171,7 @@ func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilStringInt32 + Response = []NilIP ) response, err = middleware.HookMiddleware[ Request, @@ -92173,12 +92182,12 @@ func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt32Nullable(ctx, request) + response, err = s.h.TestResponseStringIPNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt32Nullable(ctx, request) + response, err = s.h.TestResponseStringIPNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -92186,7 +92195,7 @@ func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, ar return } - if err := encodeTestResponseStringInt32NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIPNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92195,18 +92204,18 @@ func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, ar } } -// handleTestResponseStringInt32NullableArrayRequest handles test_response_string_int32_nullable_array operation. +// handleTestResponseStringIPNullableArrayArrayRequest handles test_response_string_ip_nullable_array_array operation. // -// POST /test_response_string_int32_nullable_array -func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ip_nullable_array_array +func (s *Server) handleTestResponseStringIPNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int32_nullable_array"), + otelogen.OperationID("test_response_string_ip_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int32_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_ip_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIPNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92231,11 +92240,11 @@ func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt32NullableArray", - ID: "test_response_string_int32_nullable_array", + Name: "TestResponseStringIPNullableArrayArray", + ID: "test_response_string_ip_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringInt32NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringIPNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92251,13 +92260,13 @@ func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]strin } }() - var response []NilStringInt32 + var response [][]NilIP if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt32NullableArray", + OperationName: "TestResponseStringIPNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_int32_nullable_array", + OperationID: "test_response_string_ip_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92266,7 +92275,7 @@ func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilStringInt32 + Response = [][]NilIP ) response, err = middleware.HookMiddleware[ Request, @@ -92277,12 +92286,12 @@ func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt32NullableArray(ctx, request) + response, err = s.h.TestResponseStringIPNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt32NullableArray(ctx, request) + response, err = s.h.TestResponseStringIPNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -92290,7 +92299,7 @@ func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]strin return } - if err := encodeTestResponseStringInt32NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIPNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92299,18 +92308,18 @@ func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]strin } } -// handleTestResponseStringInt32NullableArrayArrayRequest handles test_response_string_int32_nullable_array_array operation. +// handleTestResponseStringIntRequest handles test_response_string_int operation. // -// POST /test_response_string_int32_nullable_array_array -func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int +func (s *Server) handleTestResponseStringIntRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int32_nullable_array_array"), + otelogen.OperationID("test_response_string_int"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int32_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_int"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92335,11 +92344,11 @@ func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt32NullableArrayArray", - ID: "test_response_string_int32_nullable_array_array", + Name: "TestResponseStringInt", + ID: "test_response_string_int", } ) - request, close, err := s.decodeTestResponseStringInt32NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringIntRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92355,13 +92364,13 @@ func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0] } }() - var response [][]NilStringInt32 + var response int if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt32NullableArrayArray", + OperationName: "TestResponseStringInt", OperationSummary: "", - OperationID: "test_response_string_int32_nullable_array_array", + OperationID: "test_response_string_int", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92370,7 +92379,7 @@ func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilStringInt32 + Response = int ) response, err = middleware.HookMiddleware[ Request, @@ -92381,12 +92390,12 @@ func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt32NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt(ctx, request) } if err != nil { recordError("Internal", err) @@ -92394,7 +92403,7 @@ func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseStringInt32NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIntResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92403,18 +92412,18 @@ func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0] } } -// handleTestResponseStringInt64Request handles test_response_string_int64 operation. +// handleTestResponseStringInt16Request handles test_response_string_int16 operation. // -// POST /test_response_string_int64 -func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int16 +func (s *Server) handleTestResponseStringInt16Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int64"), + otelogen.OperationID("test_response_string_int16"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int64"), + semconv.HTTPRouteKey.String("/test_response_string_int16"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92439,11 +92448,11 @@ func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscape } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt64", - ID: "test_response_string_int64", + Name: "TestResponseStringInt16", + ID: "test_response_string_int16", } ) - request, close, err := s.decodeTestResponseStringInt64Request(r) + request, close, err := s.decodeTestResponseStringInt16Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92459,13 +92468,13 @@ func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscape } }() - var response int64 + var response int16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt64", + OperationName: "TestResponseStringInt16", OperationSummary: "", - OperationID: "test_response_string_int64", + OperationID: "test_response_string_int16", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92474,7 +92483,7 @@ func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscape type ( Request = string Params = struct{} - Response = int64 + Response = int16 ) response, err = middleware.HookMiddleware[ Request, @@ -92485,12 +92494,12 @@ func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscape mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt64(ctx, request) + response, err = s.h.TestResponseStringInt16(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt64(ctx, request) + response, err = s.h.TestResponseStringInt16(ctx, request) } if err != nil { recordError("Internal", err) @@ -92498,7 +92507,7 @@ func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscape return } - if err := encodeTestResponseStringInt64Response(response, w, span); err != nil { + if err := encodeTestResponseStringInt16Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92507,18 +92516,18 @@ func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscape } } -// handleTestResponseStringInt64ArrayRequest handles test_response_string_int64_array operation. +// handleTestResponseStringInt16ArrayRequest handles test_response_string_int16_array operation. // -// POST /test_response_string_int64_array -func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int16_array +func (s *Server) handleTestResponseStringInt16ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int64_array"), + otelogen.OperationID("test_response_string_int16_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int64_array"), + semconv.HTTPRouteKey.String("/test_response_string_int16_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92543,11 +92552,11 @@ func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsE } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt64Array", - ID: "test_response_string_int64_array", + Name: "TestResponseStringInt16Array", + ID: "test_response_string_int16_array", } ) - request, close, err := s.decodeTestResponseStringInt64ArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt16ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92563,13 +92572,13 @@ func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsE } }() - var response []int64 + var response []int16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt64Array", + OperationName: "TestResponseStringInt16Array", OperationSummary: "", - OperationID: "test_response_string_int64_array", + OperationID: "test_response_string_int16_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92578,7 +92587,7 @@ func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsE type ( Request = string Params = struct{} - Response = []int64 + Response = []int16 ) response, err = middleware.HookMiddleware[ Request, @@ -92589,12 +92598,12 @@ func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsE mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt64Array(ctx, request) + response, err = s.h.TestResponseStringInt16Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt64Array(ctx, request) + response, err = s.h.TestResponseStringInt16Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -92602,7 +92611,7 @@ func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsE return } - if err := encodeTestResponseStringInt64ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt16ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92611,18 +92620,18 @@ func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsE } } -// handleTestResponseStringInt64ArrayArrayRequest handles test_response_string_int64_array_array operation. +// handleTestResponseStringInt16ArrayArrayRequest handles test_response_string_int16_array_array operation. // -// POST /test_response_string_int64_array_array -func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int16_array_array +func (s *Server) handleTestResponseStringInt16ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int64_array_array"), + otelogen.OperationID("test_response_string_int16_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int64_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_int16_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92647,11 +92656,11 @@ func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt64ArrayArray", - ID: "test_response_string_int64_array_array", + Name: "TestResponseStringInt16ArrayArray", + ID: "test_response_string_int16_array_array", } ) - request, close, err := s.decodeTestResponseStringInt64ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt16ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92667,13 +92676,13 @@ func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, } }() - var response [][]int64 + var response [][]int16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt64ArrayArray", + OperationName: "TestResponseStringInt16ArrayArray", OperationSummary: "", - OperationID: "test_response_string_int64_array_array", + OperationID: "test_response_string_int16_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92682,7 +92691,7 @@ func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = [][]int64 + Response = [][]int16 ) response, err = middleware.HookMiddleware[ Request, @@ -92693,12 +92702,12 @@ func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt64ArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt16ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt64ArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt16ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -92706,7 +92715,7 @@ func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, return } - if err := encodeTestResponseStringInt64ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt16ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92715,18 +92724,18 @@ func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, } } -// handleTestResponseStringInt64NullableRequest handles test_response_string_int64_nullable operation. +// handleTestResponseStringInt16NullableRequest handles test_response_string_int16_nullable operation. // -// POST /test_response_string_int64_nullable -func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int16_nullable +func (s *Server) handleTestResponseStringInt16NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int64_nullable"), + otelogen.OperationID("test_response_string_int16_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int64_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_int16_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92751,11 +92760,11 @@ func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt64Nullable", - ID: "test_response_string_int64_nullable", + Name: "TestResponseStringInt16Nullable", + ID: "test_response_string_int16_nullable", } ) - request, close, err := s.decodeTestResponseStringInt64NullableRequest(r) + request, close, err := s.decodeTestResponseStringInt16NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92771,13 +92780,13 @@ func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, ar } }() - var response NilStringInt64 + var response NilStringInt16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt64Nullable", + OperationName: "TestResponseStringInt16Nullable", OperationSummary: "", - OperationID: "test_response_string_int64_nullable", + OperationID: "test_response_string_int16_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92786,7 +92795,7 @@ func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = NilStringInt64 + Response = NilStringInt16 ) response, err = middleware.HookMiddleware[ Request, @@ -92797,12 +92806,12 @@ func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt64Nullable(ctx, request) + response, err = s.h.TestResponseStringInt16Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt64Nullable(ctx, request) + response, err = s.h.TestResponseStringInt16Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -92810,7 +92819,7 @@ func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, ar return } - if err := encodeTestResponseStringInt64NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt16NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92819,18 +92828,18 @@ func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, ar } } -// handleTestResponseStringInt64NullableArrayRequest handles test_response_string_int64_nullable_array operation. +// handleTestResponseStringInt16NullableArrayRequest handles test_response_string_int16_nullable_array operation. // -// POST /test_response_string_int64_nullable_array -func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int16_nullable_array +func (s *Server) handleTestResponseStringInt16NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int64_nullable_array"), + otelogen.OperationID("test_response_string_int16_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int64_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_int16_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92855,11 +92864,11 @@ func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]strin } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt64NullableArray", - ID: "test_response_string_int64_nullable_array", + Name: "TestResponseStringInt16NullableArray", + ID: "test_response_string_int16_nullable_array", } ) - request, close, err := s.decodeTestResponseStringInt64NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt16NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92875,13 +92884,13 @@ func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]strin } }() - var response []NilStringInt64 + var response []NilStringInt16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt64NullableArray", + OperationName: "TestResponseStringInt16NullableArray", OperationSummary: "", - OperationID: "test_response_string_int64_nullable_array", + OperationID: "test_response_string_int16_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92890,7 +92899,7 @@ func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]strin type ( Request = string Params = struct{} - Response = []NilStringInt64 + Response = []NilStringInt16 ) response, err = middleware.HookMiddleware[ Request, @@ -92901,12 +92910,12 @@ func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]strin mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt64NullableArray(ctx, request) + response, err = s.h.TestResponseStringInt16NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt64NullableArray(ctx, request) + response, err = s.h.TestResponseStringInt16NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -92914,7 +92923,7 @@ func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]strin return } - if err := encodeTestResponseStringInt64NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt16NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -92923,18 +92932,18 @@ func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]strin } } -// handleTestResponseStringInt64NullableArrayArrayRequest handles test_response_string_int64_nullable_array_array operation. +// handleTestResponseStringInt16NullableArrayArrayRequest handles test_response_string_int16_nullable_array_array operation. // -// POST /test_response_string_int64_nullable_array_array -func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int16_nullable_array_array +func (s *Server) handleTestResponseStringInt16NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int64_nullable_array_array"), + otelogen.OperationID("test_response_string_int16_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int64_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_int16_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt16NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -92959,11 +92968,11 @@ func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0] } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt64NullableArrayArray", - ID: "test_response_string_int64_nullable_array_array", + Name: "TestResponseStringInt16NullableArrayArray", + ID: "test_response_string_int16_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringInt64NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt16NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -92979,13 +92988,13 @@ func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0] } }() - var response [][]NilStringInt64 + var response [][]NilStringInt16 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt64NullableArrayArray", + OperationName: "TestResponseStringInt16NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_int64_nullable_array_array", + OperationID: "test_response_string_int16_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -92994,7 +93003,7 @@ func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0] type ( Request = string Params = struct{} - Response = [][]NilStringInt64 + Response = [][]NilStringInt16 ) response, err = middleware.HookMiddleware[ Request, @@ -93005,12 +93014,12 @@ func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0] mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt16NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt64NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt16NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -93018,7 +93027,7 @@ func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0] return } - if err := encodeTestResponseStringInt64NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt16NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93027,18 +93036,18 @@ func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0] } } -// handleTestResponseStringInt8Request handles test_response_string_int8 operation. +// handleTestResponseStringInt32Request handles test_response_string_int32 operation. // -// POST /test_response_string_int8 -func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int32 +func (s *Server) handleTestResponseStringInt32Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int8"), + otelogen.OperationID("test_response_string_int32"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int8"), + semconv.HTTPRouteKey.String("/test_response_string_int32"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93063,11 +93072,11 @@ func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt8", - ID: "test_response_string_int8", + Name: "TestResponseStringInt32", + ID: "test_response_string_int32", } ) - request, close, err := s.decodeTestResponseStringInt8Request(r) + request, close, err := s.decodeTestResponseStringInt32Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93083,13 +93092,13 @@ func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped } }() - var response int8 + var response int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt8", + OperationName: "TestResponseStringInt32", OperationSummary: "", - OperationID: "test_response_string_int8", + OperationID: "test_response_string_int32", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93098,7 +93107,7 @@ func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped type ( Request = string Params = struct{} - Response = int8 + Response = int32 ) response, err = middleware.HookMiddleware[ Request, @@ -93109,12 +93118,12 @@ func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt8(ctx, request) + response, err = s.h.TestResponseStringInt32(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt8(ctx, request) + response, err = s.h.TestResponseStringInt32(ctx, request) } if err != nil { recordError("Internal", err) @@ -93122,7 +93131,7 @@ func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped return } - if err := encodeTestResponseStringInt8Response(response, w, span); err != nil { + if err := encodeTestResponseStringInt32Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93131,18 +93140,18 @@ func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped } } -// handleTestResponseStringInt8ArrayRequest handles test_response_string_int8_array operation. +// handleTestResponseStringInt32ArrayRequest handles test_response_string_int32_array operation. // -// POST /test_response_string_int8_array -func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int32_array +func (s *Server) handleTestResponseStringInt32ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int8_array"), + otelogen.OperationID("test_response_string_int32_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int8_array"), + semconv.HTTPRouteKey.String("/test_response_string_int32_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93167,11 +93176,11 @@ func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt8Array", - ID: "test_response_string_int8_array", + Name: "TestResponseStringInt32Array", + ID: "test_response_string_int32_array", } ) - request, close, err := s.decodeTestResponseStringInt8ArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt32ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93187,13 +93196,13 @@ func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEs } }() - var response []int8 + var response []int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt8Array", + OperationName: "TestResponseStringInt32Array", OperationSummary: "", - OperationID: "test_response_string_int8_array", + OperationID: "test_response_string_int32_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93202,7 +93211,7 @@ func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEs type ( Request = string Params = struct{} - Response = []int8 + Response = []int32 ) response, err = middleware.HookMiddleware[ Request, @@ -93213,12 +93222,12 @@ func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt8Array(ctx, request) + response, err = s.h.TestResponseStringInt32Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt8Array(ctx, request) + response, err = s.h.TestResponseStringInt32Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -93226,7 +93235,7 @@ func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEs return } - if err := encodeTestResponseStringInt8ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt32ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93235,18 +93244,18 @@ func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEs } } -// handleTestResponseStringInt8ArrayArrayRequest handles test_response_string_int8_array_array operation. +// handleTestResponseStringInt32ArrayArrayRequest handles test_response_string_int32_array_array operation. // -// POST /test_response_string_int8_array_array -func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int32_array_array +func (s *Server) handleTestResponseStringInt32ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int8_array_array"), + otelogen.OperationID("test_response_string_int32_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int8_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_int32_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93271,11 +93280,11 @@ func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt8ArrayArray", - ID: "test_response_string_int8_array_array", + Name: "TestResponseStringInt32ArrayArray", + ID: "test_response_string_int32_array_array", } ) - request, close, err := s.decodeTestResponseStringInt8ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt32ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93291,13 +93300,13 @@ func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, a } }() - var response [][]int8 + var response [][]int32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt8ArrayArray", + OperationName: "TestResponseStringInt32ArrayArray", OperationSummary: "", - OperationID: "test_response_string_int8_array_array", + OperationID: "test_response_string_int32_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93306,7 +93315,7 @@ func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, a type ( Request = string Params = struct{} - Response = [][]int8 + Response = [][]int32 ) response, err = middleware.HookMiddleware[ Request, @@ -93317,12 +93326,12 @@ func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt8ArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt32ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt8ArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt32ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -93330,7 +93339,7 @@ func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, a return } - if err := encodeTestResponseStringInt8ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt32ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93339,18 +93348,18 @@ func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, a } } -// handleTestResponseStringInt8NullableRequest handles test_response_string_int8_nullable operation. +// handleTestResponseStringInt32NullableRequest handles test_response_string_int32_nullable operation. // -// POST /test_response_string_int8_nullable -func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int32_nullable +func (s *Server) handleTestResponseStringInt32NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int8_nullable"), + otelogen.OperationID("test_response_string_int32_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int8_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_int32_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93375,11 +93384,11 @@ func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt8Nullable", - ID: "test_response_string_int8_nullable", + Name: "TestResponseStringInt32Nullable", + ID: "test_response_string_int32_nullable", } ) - request, close, err := s.decodeTestResponseStringInt8NullableRequest(r) + request, close, err := s.decodeTestResponseStringInt32NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93395,13 +93404,13 @@ func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, arg } }() - var response NilStringInt8 + var response NilStringInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt8Nullable", + OperationName: "TestResponseStringInt32Nullable", OperationSummary: "", - OperationID: "test_response_string_int8_nullable", + OperationID: "test_response_string_int32_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93410,7 +93419,7 @@ func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = NilStringInt8 + Response = NilStringInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -93421,12 +93430,12 @@ func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt8Nullable(ctx, request) + response, err = s.h.TestResponseStringInt32Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt8Nullable(ctx, request) + response, err = s.h.TestResponseStringInt32Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -93434,7 +93443,7 @@ func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, arg return } - if err := encodeTestResponseStringInt8NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt32NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93443,18 +93452,18 @@ func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, arg } } -// handleTestResponseStringInt8NullableArrayRequest handles test_response_string_int8_nullable_array operation. +// handleTestResponseStringInt32NullableArrayRequest handles test_response_string_int32_nullable_array operation. // -// POST /test_response_string_int8_nullable_array -func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int32_nullable_array +func (s *Server) handleTestResponseStringInt32NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int8_nullable_array"), + otelogen.OperationID("test_response_string_int32_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int8_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_int32_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93479,11 +93488,11 @@ func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt8NullableArray", - ID: "test_response_string_int8_nullable_array", + Name: "TestResponseStringInt32NullableArray", + ID: "test_response_string_int32_nullable_array", } ) - request, close, err := s.decodeTestResponseStringInt8NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt32NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93499,13 +93508,13 @@ func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string } }() - var response []NilStringInt8 + var response []NilStringInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt8NullableArray", + OperationName: "TestResponseStringInt32NullableArray", OperationSummary: "", - OperationID: "test_response_string_int8_nullable_array", + OperationID: "test_response_string_int32_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93514,7 +93523,7 @@ func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = []NilStringInt8 + Response = []NilStringInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -93525,12 +93534,12 @@ func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt8NullableArray(ctx, request) + response, err = s.h.TestResponseStringInt32NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt8NullableArray(ctx, request) + response, err = s.h.TestResponseStringInt32NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -93538,7 +93547,7 @@ func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string return } - if err := encodeTestResponseStringInt8NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt32NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93547,18 +93556,18 @@ func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string } } -// handleTestResponseStringInt8NullableArrayArrayRequest handles test_response_string_int8_nullable_array_array operation. +// handleTestResponseStringInt32NullableArrayArrayRequest handles test_response_string_int32_nullable_array_array operation. // -// POST /test_response_string_int8_nullable_array_array -func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int32_nullable_array_array +func (s *Server) handleTestResponseStringInt32NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int8_nullable_array_array"), + otelogen.OperationID("test_response_string_int32_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int8_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_int32_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt32NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93583,11 +93592,11 @@ func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringInt8NullableArrayArray", - ID: "test_response_string_int8_nullable_array_array", + Name: "TestResponseStringInt32NullableArrayArray", + ID: "test_response_string_int32_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringInt8NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt32NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93603,13 +93612,13 @@ func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]s } }() - var response [][]NilStringInt8 + var response [][]NilStringInt32 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringInt8NullableArrayArray", + OperationName: "TestResponseStringInt32NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_int8_nullable_array_array", + OperationID: "test_response_string_int32_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93618,7 +93627,7 @@ func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]s type ( Request = string Params = struct{} - Response = [][]NilStringInt8 + Response = [][]NilStringInt32 ) response, err = middleware.HookMiddleware[ Request, @@ -93629,12 +93638,12 @@ func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringInt8NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt32NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringInt8NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt32NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -93642,7 +93651,7 @@ func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]s return } - if err := encodeTestResponseStringInt8NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt32NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93651,18 +93660,18 @@ func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]s } } -// handleTestResponseStringIntArrayRequest handles test_response_string_int_array operation. +// handleTestResponseStringInt64Request handles test_response_string_int64 operation. // -// POST /test_response_string_int_array -func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int64 +func (s *Server) handleTestResponseStringInt64Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int_array"), + otelogen.OperationID("test_response_string_int64"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int_array"), + semconv.HTTPRouteKey.String("/test_response_string_int64"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93687,11 +93696,11 @@ func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEsc } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIntArray", - ID: "test_response_string_int_array", + Name: "TestResponseStringInt64", + ID: "test_response_string_int64", } ) - request, close, err := s.decodeTestResponseStringIntArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt64Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93707,13 +93716,13 @@ func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEsc } }() - var response []int + var response int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIntArray", + OperationName: "TestResponseStringInt64", OperationSummary: "", - OperationID: "test_response_string_int_array", + OperationID: "test_response_string_int64", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93722,7 +93731,7 @@ func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEsc type ( Request = string Params = struct{} - Response = []int + Response = int64 ) response, err = middleware.HookMiddleware[ Request, @@ -93733,12 +93742,12 @@ func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEsc mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIntArray(ctx, request) + response, err = s.h.TestResponseStringInt64(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIntArray(ctx, request) + response, err = s.h.TestResponseStringInt64(ctx, request) } if err != nil { recordError("Internal", err) @@ -93746,7 +93755,7 @@ func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEsc return } - if err := encodeTestResponseStringIntArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt64Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93755,18 +93764,18 @@ func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEsc } } -// handleTestResponseStringIntArrayArrayRequest handles test_response_string_int_array_array operation. +// handleTestResponseStringInt64ArrayRequest handles test_response_string_int64_array operation. // -// POST /test_response_string_int_array_array -func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int64_array +func (s *Server) handleTestResponseStringInt64ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int_array_array"), + otelogen.OperationID("test_response_string_int64_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_int64_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93791,11 +93800,11 @@ func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, ar } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIntArrayArray", - ID: "test_response_string_int_array_array", + Name: "TestResponseStringInt64Array", + ID: "test_response_string_int64_array", } ) - request, close, err := s.decodeTestResponseStringIntArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringInt64ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93811,13 +93820,13 @@ func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, ar } }() - var response [][]int + var response []int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIntArrayArray", + OperationName: "TestResponseStringInt64Array", OperationSummary: "", - OperationID: "test_response_string_int_array_array", + OperationID: "test_response_string_int64_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93826,7 +93835,7 @@ func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, ar type ( Request = string Params = struct{} - Response = [][]int + Response = []int64 ) response, err = middleware.HookMiddleware[ Request, @@ -93837,12 +93846,12 @@ func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, ar mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIntArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt64Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIntArrayArray(ctx, request) + response, err = s.h.TestResponseStringInt64Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -93850,7 +93859,7 @@ func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, ar return } - if err := encodeTestResponseStringIntArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt64ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93859,18 +93868,18 @@ func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, ar } } -// handleTestResponseStringIntNullableRequest handles test_response_string_int_nullable operation. +// handleTestResponseStringInt64ArrayArrayRequest handles test_response_string_int64_array_array operation. // -// POST /test_response_string_int_nullable -func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int64_array_array +func (s *Server) handleTestResponseStringInt64ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int_nullable"), + otelogen.OperationID("test_response_string_int64_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_int64_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntNullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -93895,11 +93904,11 @@ func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, args } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIntNullable", - ID: "test_response_string_int_nullable", + Name: "TestResponseStringInt64ArrayArray", + ID: "test_response_string_int64_array_array", } ) - request, close, err := s.decodeTestResponseStringIntNullableRequest(r) + request, close, err := s.decodeTestResponseStringInt64ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -93915,13 +93924,13 @@ func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, args } }() - var response NilStringInt + var response [][]int64 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIntNullable", + OperationName: "TestResponseStringInt64ArrayArray", OperationSummary: "", - OperationID: "test_response_string_int_nullable", + OperationID: "test_response_string_int64_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -93930,7 +93939,7 @@ func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, args type ( Request = string Params = struct{} - Response = NilStringInt + Response = [][]int64 ) response, err = middleware.HookMiddleware[ Request, @@ -93941,12 +93950,12 @@ func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, args mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIntNullable(ctx, request) + response, err = s.h.TestResponseStringInt64ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIntNullable(ctx, request) + response, err = s.h.TestResponseStringInt64ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -93954,7 +93963,7 @@ func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, args return } - if err := encodeTestResponseStringIntNullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringInt64ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -93963,18 +93972,1266 @@ func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, args } } -// handleTestResponseStringIntNullableArrayRequest handles test_response_string_int_nullable_array operation. +// handleTestResponseStringInt64NullableRequest handles test_response_string_int64_nullable operation. // -// POST /test_response_string_int_nullable_array -func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_int64_nullable +func (s *Server) handleTestResponseStringInt64NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int_nullable_array"), + otelogen.OperationID("test_response_string_int64_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_int64_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntNullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64Nullable", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt64Nullable", + ID: "test_response_string_int64_nullable", + } + ) + request, close, err := s.decodeTestResponseStringInt64NullableRequest(r) + 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 NilStringInt64 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt64Nullable", + OperationSummary: "", + OperationID: "test_response_string_int64_nullable", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = NilStringInt64 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt64Nullable(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt64Nullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt64NullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt64NullableArrayRequest handles test_response_string_int64_nullable_array operation. +// +// POST /test_response_string_int64_nullable_array +func (s *Server) handleTestResponseStringInt64NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int64_nullable_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int64_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64NullableArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt64NullableArray", + ID: "test_response_string_int64_nullable_array", + } + ) + request, close, err := s.decodeTestResponseStringInt64NullableArrayRequest(r) + 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 []NilStringInt64 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt64NullableArray", + OperationSummary: "", + OperationID: "test_response_string_int64_nullable_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []NilStringInt64 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt64NullableArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt64NullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt64NullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt64NullableArrayArrayRequest handles test_response_string_int64_nullable_array_array operation. +// +// POST /test_response_string_int64_nullable_array_array +func (s *Server) handleTestResponseStringInt64NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int64_nullable_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int64_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt64NullableArrayArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt64NullableArrayArray", + ID: "test_response_string_int64_nullable_array_array", + } + ) + request, close, err := s.decodeTestResponseStringInt64NullableArrayArrayRequest(r) + 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 [][]NilStringInt64 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt64NullableArrayArray", + OperationSummary: "", + OperationID: "test_response_string_int64_nullable_array_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]NilStringInt64 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt64NullableArrayArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt64NullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt64NullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt8Request handles test_response_string_int8 operation. +// +// POST /test_response_string_int8 +func (s *Server) handleTestResponseStringInt8Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int8"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int8"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt8", + ID: "test_response_string_int8", + } + ) + request, close, err := s.decodeTestResponseStringInt8Request(r) + 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 int8 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt8", + OperationSummary: "", + OperationID: "test_response_string_int8", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = int8 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt8(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt8(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt8Response(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt8ArrayRequest handles test_response_string_int8_array operation. +// +// POST /test_response_string_int8_array +func (s *Server) handleTestResponseStringInt8ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int8_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int8_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8Array", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt8Array", + ID: "test_response_string_int8_array", + } + ) + request, close, err := s.decodeTestResponseStringInt8ArrayRequest(r) + 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 []int8 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt8Array", + OperationSummary: "", + OperationID: "test_response_string_int8_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []int8 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt8Array(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt8Array(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt8ArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt8ArrayArrayRequest handles test_response_string_int8_array_array operation. +// +// POST /test_response_string_int8_array_array +func (s *Server) handleTestResponseStringInt8ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int8_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int8_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8ArrayArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt8ArrayArray", + ID: "test_response_string_int8_array_array", + } + ) + request, close, err := s.decodeTestResponseStringInt8ArrayArrayRequest(r) + 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 [][]int8 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt8ArrayArray", + OperationSummary: "", + OperationID: "test_response_string_int8_array_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]int8 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt8ArrayArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt8ArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt8ArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt8NullableRequest handles test_response_string_int8_nullable operation. +// +// POST /test_response_string_int8_nullable +func (s *Server) handleTestResponseStringInt8NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int8_nullable"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int8_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8Nullable", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt8Nullable", + ID: "test_response_string_int8_nullable", + } + ) + request, close, err := s.decodeTestResponseStringInt8NullableRequest(r) + 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 NilStringInt8 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt8Nullable", + OperationSummary: "", + OperationID: "test_response_string_int8_nullable", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = NilStringInt8 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt8Nullable(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt8Nullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt8NullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt8NullableArrayRequest handles test_response_string_int8_nullable_array operation. +// +// POST /test_response_string_int8_nullable_array +func (s *Server) handleTestResponseStringInt8NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int8_nullable_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int8_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8NullableArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt8NullableArray", + ID: "test_response_string_int8_nullable_array", + } + ) + request, close, err := s.decodeTestResponseStringInt8NullableArrayRequest(r) + 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 []NilStringInt8 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt8NullableArray", + OperationSummary: "", + OperationID: "test_response_string_int8_nullable_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []NilStringInt8 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt8NullableArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt8NullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt8NullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringInt8NullableArrayArrayRequest handles test_response_string_int8_nullable_array_array operation. +// +// POST /test_response_string_int8_nullable_array_array +func (s *Server) handleTestResponseStringInt8NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int8_nullable_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int8_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringInt8NullableArrayArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringInt8NullableArrayArray", + ID: "test_response_string_int8_nullable_array_array", + } + ) + request, close, err := s.decodeTestResponseStringInt8NullableArrayArrayRequest(r) + 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 [][]NilStringInt8 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringInt8NullableArrayArray", + OperationSummary: "", + OperationID: "test_response_string_int8_nullable_array_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]NilStringInt8 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringInt8NullableArrayArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringInt8NullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringInt8NullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIntArrayRequest handles test_response_string_int_array operation. +// +// POST /test_response_string_int_array +func (s *Server) handleTestResponseStringIntArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIntArray", + ID: "test_response_string_int_array", + } + ) + request, close, err := s.decodeTestResponseStringIntArrayRequest(r) + 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: "TestResponseStringIntArray", + OperationSummary: "", + OperationID: "test_response_string_int_array", + Body: request, + Params: middleware.Parameters{}, + 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 Response, err error) { + response, err = s.h.TestResponseStringIntArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIntArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIntArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIntArrayArrayRequest handles test_response_string_int_array_array operation. +// +// POST /test_response_string_int_array_array +func (s *Server) handleTestResponseStringIntArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntArrayArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIntArrayArray", + ID: "test_response_string_int_array_array", + } + ) + request, close, err := s.decodeTestResponseStringIntArrayArrayRequest(r) + 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: "TestResponseStringIntArrayArray", + OperationSummary: "", + OperationID: "test_response_string_int_array_array", + Body: request, + Params: middleware.Parameters{}, + 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 Response, err error) { + response, err = s.h.TestResponseStringIntArrayArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIntArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIntArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIntNullableRequest handles test_response_string_int_nullable operation. +// +// POST /test_response_string_int_nullable +func (s *Server) handleTestResponseStringIntNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int_nullable"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntNullable", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIntNullable", + ID: "test_response_string_int_nullable", + } + ) + request, close, err := s.decodeTestResponseStringIntNullableRequest(r) + 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 NilStringInt + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringIntNullable", + OperationSummary: "", + OperationID: "test_response_string_int_nullable", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = NilStringInt + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringIntNullable(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIntNullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIntNullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIntNullableArrayRequest handles test_response_string_int_nullable_array operation. +// +// POST /test_response_string_int_nullable_array +func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int_nullable_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94003,7 +95260,215 @@ func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, ID: "test_response_string_int_nullable_array", } ) - request, close, err := s.decodeTestResponseStringIntNullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringIntNullableArrayRequest(r) + 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 []NilStringInt + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringIntNullableArray", + OperationSummary: "", + OperationID: "test_response_string_int_nullable_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []NilStringInt + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringIntNullableArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIntNullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIntNullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIntNullableArrayArrayRequest handles test_response_string_int_nullable_array_array operation. +// +// POST /test_response_string_int_nullable_array_array +func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_int_nullable_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_int_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntNullableArrayArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIntNullableArrayArray", + ID: "test_response_string_int_nullable_array_array", + } + ) + request, close, err := s.decodeTestResponseStringIntNullableArrayArrayRequest(r) + 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 [][]NilStringInt + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringIntNullableArrayArray", + OperationSummary: "", + OperationID: "test_response_string_int_nullable_array_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]NilStringInt + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringIntNullableArrayArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIntNullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIntNullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIpv4Request handles test_response_string_ipv4 operation. +// +// POST /test_response_string_ipv4 +func (s *Server) handleTestResponseStringIpv4Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_ipv4"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_ipv4"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIpv4", + ID: "test_response_string_ipv4", + } + ) + request, close, err := s.decodeTestResponseStringIpv4Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94019,13 +95484,13 @@ func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, } }() - var response []NilStringInt + var response netip.Addr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIntNullableArray", + OperationName: "TestResponseStringIpv4", OperationSummary: "", - OperationID: "test_response_string_int_nullable_array", + OperationID: "test_response_string_ipv4", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94034,7 +95499,7 @@ func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, type ( Request = string Params = struct{} - Response = []NilStringInt + Response = netip.Addr ) response, err = middleware.HookMiddleware[ Request, @@ -94045,12 +95510,12 @@ func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIntNullableArray(ctx, request) + response, err = s.h.TestResponseStringIpv4(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIntNullableArray(ctx, request) + response, err = s.h.TestResponseStringIpv4(ctx, request) } if err != nil { recordError("Internal", err) @@ -94058,7 +95523,7 @@ func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, return } - if err := encodeTestResponseStringIntNullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIpv4Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94067,18 +95532,18 @@ func (s *Server) handleTestResponseStringIntNullableArrayRequest(args [0]string, } } -// handleTestResponseStringIntNullableArrayArrayRequest handles test_response_string_int_nullable_array_array operation. +// handleTestResponseStringIpv4ArrayRequest handles test_response_string_ipv4_array operation. // -// POST /test_response_string_int_nullable_array_array -func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ipv4_array +func (s *Server) handleTestResponseStringIpv4ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_int_nullable_array_array"), + otelogen.OperationID("test_response_string_ipv4_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_int_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_ipv4_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIntNullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94103,11 +95568,11 @@ func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]st } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIntNullableArrayArray", - ID: "test_response_string_int_nullable_array_array", + Name: "TestResponseStringIpv4Array", + ID: "test_response_string_ipv4_array", } ) - request, close, err := s.decodeTestResponseStringIntNullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringIpv4ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94123,13 +95588,13 @@ func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]st } }() - var response [][]NilStringInt + var response []netip.Addr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIntNullableArrayArray", + OperationName: "TestResponseStringIpv4Array", OperationSummary: "", - OperationID: "test_response_string_int_nullable_array_array", + OperationID: "test_response_string_ipv4_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94138,7 +95603,7 @@ func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]st type ( Request = string Params = struct{} - Response = [][]NilStringInt + Response = []netip.Addr ) response, err = middleware.HookMiddleware[ Request, @@ -94149,12 +95614,12 @@ func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]st mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIntNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringIpv4Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIntNullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringIpv4Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -94162,7 +95627,7 @@ func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]st return } - if err := encodeTestResponseStringIntNullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIpv4ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94171,18 +95636,434 @@ func (s *Server) handleTestResponseStringIntNullableArrayArrayRequest(args [0]st } } -// handleTestResponseStringIpv4Request handles test_response_string_ipv4 operation. +// handleTestResponseStringIpv4ArrayArrayRequest handles test_response_string_ipv4_array_array operation. // -// POST /test_response_string_ipv4 -func (s *Server) handleTestResponseStringIpv4Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ipv4_array_array +func (s *Server) handleTestResponseStringIpv4ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv4"), + otelogen.OperationID("test_response_string_ipv4_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv4"), + semconv.HTTPRouteKey.String("/test_response_string_ipv4_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4ArrayArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIpv4ArrayArray", + ID: "test_response_string_ipv4_array_array", + } + ) + request, close, err := s.decodeTestResponseStringIpv4ArrayArrayRequest(r) + 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 [][]netip.Addr + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringIpv4ArrayArray", + OperationSummary: "", + OperationID: "test_response_string_ipv4_array_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]netip.Addr + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringIpv4ArrayArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIpv4ArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIpv4ArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIpv4NullableRequest handles test_response_string_ipv4_nullable operation. +// +// POST /test_response_string_ipv4_nullable +func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_ipv4_nullable"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_ipv4_nullable"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4Nullable", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIpv4Nullable", + ID: "test_response_string_ipv4_nullable", + } + ) + request, close, err := s.decodeTestResponseStringIpv4NullableRequest(r) + 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 NilIPv4 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringIpv4Nullable", + OperationSummary: "", + OperationID: "test_response_string_ipv4_nullable", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = NilIPv4 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringIpv4Nullable(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIpv4Nullable(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIpv4NullableResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIpv4NullableArrayRequest handles test_response_string_ipv4_nullable_array operation. +// +// POST /test_response_string_ipv4_nullable_array +func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_ipv4_nullable_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_ipv4_nullable_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4NullableArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIpv4NullableArray", + ID: "test_response_string_ipv4_nullable_array", + } + ) + request, close, err := s.decodeTestResponseStringIpv4NullableArrayRequest(r) + 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 []NilIPv4 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringIpv4NullableArray", + OperationSummary: "", + OperationID: "test_response_string_ipv4_nullable_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = []NilIPv4 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringIpv4NullableArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIpv4NullableArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIpv4NullableArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIpv4NullableArrayArrayRequest handles test_response_string_ipv4_nullable_array_array operation. +// +// POST /test_response_string_ipv4_nullable_array_array +func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_ipv4_nullable_array_array"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_ipv4_nullable_array_array"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4NullableArrayArray", + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + s.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + s.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: "TestResponseStringIpv4NullableArrayArray", + ID: "test_response_string_ipv4_nullable_array_array", + } + ) + request, close, err := s.decodeTestResponseStringIpv4NullableArrayArrayRequest(r) + 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 [][]NilIPv4 + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: "TestResponseStringIpv4NullableArrayArray", + OperationSummary: "", + OperationID: "test_response_string_ipv4_nullable_array_array", + Body: request, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = string + Params = struct{} + Response = [][]NilIPv4 + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.TestResponseStringIpv4NullableArrayArray(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.TestResponseStringIpv4NullableArrayArray(ctx, request) + } + if err != nil { + recordError("Internal", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + if err := encodeTestResponseStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { + recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handleTestResponseStringIpv6Request handles test_response_string_ipv6 operation. +// +// POST /test_response_string_ipv6 +func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("test_response_string_ipv6"), + semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/test_response_string_ipv6"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94207,11 +96088,11 @@ func (s *Server) handleTestResponseStringIpv4Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv4", - ID: "test_response_string_ipv4", + Name: "TestResponseStringIpv6", + ID: "test_response_string_ipv6", } ) - request, close, err := s.decodeTestResponseStringIpv4Request(r) + request, close, err := s.decodeTestResponseStringIpv6Request(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94231,9 +96112,9 @@ func (s *Server) handleTestResponseStringIpv4Request(args [0]string, argsEscaped if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv4", + OperationName: "TestResponseStringIpv6", OperationSummary: "", - OperationID: "test_response_string_ipv4", + OperationID: "test_response_string_ipv6", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94253,12 +96134,12 @@ func (s *Server) handleTestResponseStringIpv4Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv4(ctx, request) + response, err = s.h.TestResponseStringIpv6(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv4(ctx, request) + response, err = s.h.TestResponseStringIpv6(ctx, request) } if err != nil { recordError("Internal", err) @@ -94266,7 +96147,7 @@ func (s *Server) handleTestResponseStringIpv4Request(args [0]string, argsEscaped return } - if err := encodeTestResponseStringIpv4Response(response, w, span); err != nil { + if err := encodeTestResponseStringIpv6Response(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94275,18 +96156,18 @@ func (s *Server) handleTestResponseStringIpv4Request(args [0]string, argsEscaped } } -// handleTestResponseStringIpv4ArrayRequest handles test_response_string_ipv4_array operation. +// handleTestResponseStringIpv6ArrayRequest handles test_response_string_ipv6_array operation. // -// POST /test_response_string_ipv4_array -func (s *Server) handleTestResponseStringIpv4ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ipv6_array +func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv4_array"), + otelogen.OperationID("test_response_string_ipv6_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv4_array"), + semconv.HTTPRouteKey.String("/test_response_string_ipv6_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6Array", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94311,11 +96192,11 @@ func (s *Server) handleTestResponseStringIpv4ArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv4Array", - ID: "test_response_string_ipv4_array", + Name: "TestResponseStringIpv6Array", + ID: "test_response_string_ipv6_array", } ) - request, close, err := s.decodeTestResponseStringIpv4ArrayRequest(r) + request, close, err := s.decodeTestResponseStringIpv6ArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94335,9 +96216,9 @@ func (s *Server) handleTestResponseStringIpv4ArrayRequest(args [0]string, argsEs if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv4Array", + OperationName: "TestResponseStringIpv6Array", OperationSummary: "", - OperationID: "test_response_string_ipv4_array", + OperationID: "test_response_string_ipv6_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94357,12 +96238,12 @@ func (s *Server) handleTestResponseStringIpv4ArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv4Array(ctx, request) + response, err = s.h.TestResponseStringIpv6Array(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv4Array(ctx, request) + response, err = s.h.TestResponseStringIpv6Array(ctx, request) } if err != nil { recordError("Internal", err) @@ -94370,7 +96251,7 @@ func (s *Server) handleTestResponseStringIpv4ArrayRequest(args [0]string, argsEs return } - if err := encodeTestResponseStringIpv4ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIpv6ArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94379,18 +96260,18 @@ func (s *Server) handleTestResponseStringIpv4ArrayRequest(args [0]string, argsEs } } -// handleTestResponseStringIpv4ArrayArrayRequest handles test_response_string_ipv4_array_array operation. +// handleTestResponseStringIpv6ArrayArrayRequest handles test_response_string_ipv6_array_array operation. // -// POST /test_response_string_ipv4_array_array -func (s *Server) handleTestResponseStringIpv4ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ipv6_array_array +func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv4_array_array"), + otelogen.OperationID("test_response_string_ipv6_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv4_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_ipv6_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6ArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94415,11 +96296,11 @@ func (s *Server) handleTestResponseStringIpv4ArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv4ArrayArray", - ID: "test_response_string_ipv4_array_array", + Name: "TestResponseStringIpv6ArrayArray", + ID: "test_response_string_ipv6_array_array", } ) - request, close, err := s.decodeTestResponseStringIpv4ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringIpv6ArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94439,9 +96320,9 @@ func (s *Server) handleTestResponseStringIpv4ArrayArrayRequest(args [0]string, a if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv4ArrayArray", + OperationName: "TestResponseStringIpv6ArrayArray", OperationSummary: "", - OperationID: "test_response_string_ipv4_array_array", + OperationID: "test_response_string_ipv6_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94461,12 +96342,12 @@ func (s *Server) handleTestResponseStringIpv4ArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv4ArrayArray(ctx, request) + response, err = s.h.TestResponseStringIpv6ArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv4ArrayArray(ctx, request) + response, err = s.h.TestResponseStringIpv6ArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -94474,7 +96355,7 @@ func (s *Server) handleTestResponseStringIpv4ArrayArrayRequest(args [0]string, a return } - if err := encodeTestResponseStringIpv4ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIpv6ArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94483,18 +96364,18 @@ func (s *Server) handleTestResponseStringIpv4ArrayArrayRequest(args [0]string, a } } -// handleTestResponseStringIpv4NullableRequest handles test_response_string_ipv4_nullable operation. +// handleTestResponseStringIpv6NullableRequest handles test_response_string_ipv6_nullable operation. // -// POST /test_response_string_ipv4_nullable -func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ipv6_nullable +func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv4_nullable"), + otelogen.OperationID("test_response_string_ipv6_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv4_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_ipv6_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6Nullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94519,11 +96400,11 @@ func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv4Nullable", - ID: "test_response_string_ipv4_nullable", + Name: "TestResponseStringIpv6Nullable", + ID: "test_response_string_ipv6_nullable", } ) - request, close, err := s.decodeTestResponseStringIpv4NullableRequest(r) + request, close, err := s.decodeTestResponseStringIpv6NullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94539,13 +96420,13 @@ func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, arg } }() - var response NilIPv4 + var response NilIPv6 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv4Nullable", + OperationName: "TestResponseStringIpv6Nullable", OperationSummary: "", - OperationID: "test_response_string_ipv4_nullable", + OperationID: "test_response_string_ipv6_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94554,7 +96435,7 @@ func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = NilIPv4 + Response = NilIPv6 ) response, err = middleware.HookMiddleware[ Request, @@ -94565,12 +96446,12 @@ func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv4Nullable(ctx, request) + response, err = s.h.TestResponseStringIpv6Nullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv4Nullable(ctx, request) + response, err = s.h.TestResponseStringIpv6Nullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -94578,7 +96459,7 @@ func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, arg return } - if err := encodeTestResponseStringIpv4NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIpv6NullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94587,18 +96468,18 @@ func (s *Server) handleTestResponseStringIpv4NullableRequest(args [0]string, arg } } -// handleTestResponseStringIpv4NullableArrayRequest handles test_response_string_ipv4_nullable_array operation. +// handleTestResponseStringIpv6NullableArrayRequest handles test_response_string_ipv6_nullable_array operation. // -// POST /test_response_string_ipv4_nullable_array -func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ipv6_nullable_array +func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv4_nullable_array"), + otelogen.OperationID("test_response_string_ipv6_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv4_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_ipv6_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6NullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94623,11 +96504,11 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv4NullableArray", - ID: "test_response_string_ipv4_nullable_array", + Name: "TestResponseStringIpv6NullableArray", + ID: "test_response_string_ipv6_nullable_array", } ) - request, close, err := s.decodeTestResponseStringIpv4NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringIpv6NullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94643,13 +96524,13 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string } }() - var response []NilIPv4 + var response []NilIPv6 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv4NullableArray", + OperationName: "TestResponseStringIpv6NullableArray", OperationSummary: "", - OperationID: "test_response_string_ipv4_nullable_array", + OperationID: "test_response_string_ipv6_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94658,7 +96539,7 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = []NilIPv4 + Response = []NilIPv6 ) response, err = middleware.HookMiddleware[ Request, @@ -94669,12 +96550,12 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv4NullableArray(ctx, request) + response, err = s.h.TestResponseStringIpv6NullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv4NullableArray(ctx, request) + response, err = s.h.TestResponseStringIpv6NullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -94682,7 +96563,7 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string return } - if err := encodeTestResponseStringIpv4NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIpv6NullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94691,18 +96572,18 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayRequest(args [0]string } } -// handleTestResponseStringIpv4NullableArrayArrayRequest handles test_response_string_ipv4_nullable_array_array operation. +// handleTestResponseStringIpv6NullableArrayArrayRequest handles test_response_string_ipv6_nullable_array_array operation. // -// POST /test_response_string_ipv4_nullable_array_array -func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_ipv6_nullable_array_array +func (s *Server) handleTestResponseStringIpv6NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv4_nullable_array_array"), + otelogen.OperationID("test_response_string_ipv6_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv4_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_ipv6_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv4NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6NullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94727,11 +96608,11 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv4NullableArrayArray", - ID: "test_response_string_ipv4_nullable_array_array", + Name: "TestResponseStringIpv6NullableArrayArray", + ID: "test_response_string_ipv6_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringIpv4NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringIpv6NullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94747,13 +96628,13 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]s } }() - var response [][]NilIPv4 + var response [][]NilIPv6 if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv4NullableArrayArray", + OperationName: "TestResponseStringIpv6NullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_ipv4_nullable_array_array", + OperationID: "test_response_string_ipv6_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94762,7 +96643,7 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]s type ( Request = string Params = struct{} - Response = [][]NilIPv4 + Response = [][]NilIPv6 ) response, err = middleware.HookMiddleware[ Request, @@ -94773,12 +96654,12 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv4NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringIpv6NullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv4NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringIpv6NullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -94786,7 +96667,7 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]s return } - if err := encodeTestResponseStringIpv4NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94795,18 +96676,18 @@ func (s *Server) handleTestResponseStringIpv4NullableArrayArrayRequest(args [0]s } } -// handleTestResponseStringIpv6Request handles test_response_string_ipv6 operation. +// handleTestResponseStringMACRequest handles test_response_string_mac operation. // -// POST /test_response_string_ipv6 -func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_mac +func (s *Server) handleTestResponseStringMACRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv6"), + otelogen.OperationID("test_response_string_mac"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv6"), + semconv.HTTPRouteKey.String("/test_response_string_mac"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringMAC", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94831,11 +96712,11 @@ func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv6", - ID: "test_response_string_ipv6", + Name: "TestResponseStringMAC", + ID: "test_response_string_mac", } ) - request, close, err := s.decodeTestResponseStringIpv6Request(r) + request, close, err := s.decodeTestResponseStringMACRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94851,13 +96732,13 @@ func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped } }() - var response netip.Addr + var response net.HardwareAddr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv6", + OperationName: "TestResponseStringMAC", OperationSummary: "", - OperationID: "test_response_string_ipv6", + OperationID: "test_response_string_mac", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94866,7 +96747,7 @@ func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped type ( Request = string Params = struct{} - Response = netip.Addr + Response = net.HardwareAddr ) response, err = middleware.HookMiddleware[ Request, @@ -94877,12 +96758,12 @@ func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv6(ctx, request) + response, err = s.h.TestResponseStringMAC(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv6(ctx, request) + response, err = s.h.TestResponseStringMAC(ctx, request) } if err != nil { recordError("Internal", err) @@ -94890,7 +96771,7 @@ func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped return } - if err := encodeTestResponseStringIpv6Response(response, w, span); err != nil { + if err := encodeTestResponseStringMACResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -94899,18 +96780,18 @@ func (s *Server) handleTestResponseStringIpv6Request(args [0]string, argsEscaped } } -// handleTestResponseStringIpv6ArrayRequest handles test_response_string_ipv6_array operation. +// handleTestResponseStringMACArrayRequest handles test_response_string_mac_array operation. // -// POST /test_response_string_ipv6_array -func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_mac_array +func (s *Server) handleTestResponseStringMACArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv6_array"), + otelogen.OperationID("test_response_string_mac_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv6_array"), + semconv.HTTPRouteKey.String("/test_response_string_mac_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6Array", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringMACArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -94935,11 +96816,11 @@ func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEs } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv6Array", - ID: "test_response_string_ipv6_array", + Name: "TestResponseStringMACArray", + ID: "test_response_string_mac_array", } ) - request, close, err := s.decodeTestResponseStringIpv6ArrayRequest(r) + request, close, err := s.decodeTestResponseStringMACArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -94955,13 +96836,13 @@ func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEs } }() - var response []netip.Addr + var response []net.HardwareAddr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv6Array", + OperationName: "TestResponseStringMACArray", OperationSummary: "", - OperationID: "test_response_string_ipv6_array", + OperationID: "test_response_string_mac_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -94970,7 +96851,7 @@ func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEs type ( Request = string Params = struct{} - Response = []netip.Addr + Response = []net.HardwareAddr ) response, err = middleware.HookMiddleware[ Request, @@ -94981,12 +96862,12 @@ func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEs mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv6Array(ctx, request) + response, err = s.h.TestResponseStringMACArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv6Array(ctx, request) + response, err = s.h.TestResponseStringMACArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -94994,7 +96875,7 @@ func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEs return } - if err := encodeTestResponseStringIpv6ArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringMACArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -95003,18 +96884,18 @@ func (s *Server) handleTestResponseStringIpv6ArrayRequest(args [0]string, argsEs } } -// handleTestResponseStringIpv6ArrayArrayRequest handles test_response_string_ipv6_array_array operation. +// handleTestResponseStringMACArrayArrayRequest handles test_response_string_mac_array_array operation. // -// POST /test_response_string_ipv6_array_array -func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_mac_array_array +func (s *Server) handleTestResponseStringMACArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv6_array_array"), + otelogen.OperationID("test_response_string_mac_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv6_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_mac_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6ArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringMACArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -95039,11 +96920,11 @@ func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, a } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv6ArrayArray", - ID: "test_response_string_ipv6_array_array", + Name: "TestResponseStringMACArrayArray", + ID: "test_response_string_mac_array_array", } ) - request, close, err := s.decodeTestResponseStringIpv6ArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringMACArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -95059,13 +96940,13 @@ func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, a } }() - var response [][]netip.Addr + var response [][]net.HardwareAddr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv6ArrayArray", + OperationName: "TestResponseStringMACArrayArray", OperationSummary: "", - OperationID: "test_response_string_ipv6_array_array", + OperationID: "test_response_string_mac_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -95074,7 +96955,7 @@ func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, a type ( Request = string Params = struct{} - Response = [][]netip.Addr + Response = [][]net.HardwareAddr ) response, err = middleware.HookMiddleware[ Request, @@ -95085,12 +96966,12 @@ func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, a mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv6ArrayArray(ctx, request) + response, err = s.h.TestResponseStringMACArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv6ArrayArray(ctx, request) + response, err = s.h.TestResponseStringMACArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -95098,7 +96979,7 @@ func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, a return } - if err := encodeTestResponseStringIpv6ArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringMACArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -95107,18 +96988,18 @@ func (s *Server) handleTestResponseStringIpv6ArrayArrayRequest(args [0]string, a } } -// handleTestResponseStringIpv6NullableRequest handles test_response_string_ipv6_nullable operation. +// handleTestResponseStringMACNullableRequest handles test_response_string_mac_nullable operation. // -// POST /test_response_string_ipv6_nullable -func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_mac_nullable +func (s *Server) handleTestResponseStringMACNullableRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv6_nullable"), + otelogen.OperationID("test_response_string_mac_nullable"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv6_nullable"), + semconv.HTTPRouteKey.String("/test_response_string_mac_nullable"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6Nullable", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringMACNullable", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -95143,11 +97024,11 @@ func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, arg } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv6Nullable", - ID: "test_response_string_ipv6_nullable", + Name: "TestResponseStringMACNullable", + ID: "test_response_string_mac_nullable", } ) - request, close, err := s.decodeTestResponseStringIpv6NullableRequest(r) + request, close, err := s.decodeTestResponseStringMACNullableRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -95163,13 +97044,13 @@ func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, arg } }() - var response NilIPv6 + var response NilHardwareAddr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv6Nullable", + OperationName: "TestResponseStringMACNullable", OperationSummary: "", - OperationID: "test_response_string_ipv6_nullable", + OperationID: "test_response_string_mac_nullable", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -95178,7 +97059,7 @@ func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, arg type ( Request = string Params = struct{} - Response = NilIPv6 + Response = NilHardwareAddr ) response, err = middleware.HookMiddleware[ Request, @@ -95189,12 +97070,12 @@ func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, arg mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv6Nullable(ctx, request) + response, err = s.h.TestResponseStringMACNullable(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv6Nullable(ctx, request) + response, err = s.h.TestResponseStringMACNullable(ctx, request) } if err != nil { recordError("Internal", err) @@ -95202,7 +97083,7 @@ func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, arg return } - if err := encodeTestResponseStringIpv6NullableResponse(response, w, span); err != nil { + if err := encodeTestResponseStringMACNullableResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -95211,18 +97092,18 @@ func (s *Server) handleTestResponseStringIpv6NullableRequest(args [0]string, arg } } -// handleTestResponseStringIpv6NullableArrayRequest handles test_response_string_ipv6_nullable_array operation. +// handleTestResponseStringMACNullableArrayRequest handles test_response_string_mac_nullable_array operation. // -// POST /test_response_string_ipv6_nullable_array -func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_mac_nullable_array +func (s *Server) handleTestResponseStringMACNullableArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv6_nullable_array"), + otelogen.OperationID("test_response_string_mac_nullable_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv6_nullable_array"), + semconv.HTTPRouteKey.String("/test_response_string_mac_nullable_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6NullableArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringMACNullableArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -95247,11 +97128,11 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv6NullableArray", - ID: "test_response_string_ipv6_nullable_array", + Name: "TestResponseStringMACNullableArray", + ID: "test_response_string_mac_nullable_array", } ) - request, close, err := s.decodeTestResponseStringIpv6NullableArrayRequest(r) + request, close, err := s.decodeTestResponseStringMACNullableArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -95267,13 +97148,13 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string } }() - var response []NilIPv6 + var response []NilHardwareAddr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv6NullableArray", + OperationName: "TestResponseStringMACNullableArray", OperationSummary: "", - OperationID: "test_response_string_ipv6_nullable_array", + OperationID: "test_response_string_mac_nullable_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -95282,7 +97163,7 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string type ( Request = string Params = struct{} - Response = []NilIPv6 + Response = []NilHardwareAddr ) response, err = middleware.HookMiddleware[ Request, @@ -95293,12 +97174,12 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv6NullableArray(ctx, request) + response, err = s.h.TestResponseStringMACNullableArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv6NullableArray(ctx, request) + response, err = s.h.TestResponseStringMACNullableArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -95306,7 +97187,7 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string return } - if err := encodeTestResponseStringIpv6NullableArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringMACNullableArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) @@ -95315,18 +97196,18 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayRequest(args [0]string } } -// handleTestResponseStringIpv6NullableArrayArrayRequest handles test_response_string_ipv6_nullable_array_array operation. +// handleTestResponseStringMACNullableArrayArrayRequest handles test_response_string_mac_nullable_array_array operation. // -// POST /test_response_string_ipv6_nullable_array_array -func (s *Server) handleTestResponseStringIpv6NullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { +// POST /test_response_string_mac_nullable_array_array +func (s *Server) handleTestResponseStringMACNullableArrayArrayRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("test_response_string_ipv6_nullable_array_array"), + otelogen.OperationID("test_response_string_mac_nullable_array_array"), semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/test_response_string_ipv6_nullable_array_array"), + semconv.HTTPRouteKey.String("/test_response_string_mac_nullable_array_array"), } // Start a span for this request. - ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringIpv6NullableArrayArray", + ctx, span := s.cfg.Tracer.Start(r.Context(), "TestResponseStringMACNullableArrayArray", trace.WithAttributes(otelAttrs...), serverSpanKind, ) @@ -95351,11 +97232,11 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayArrayRequest(args [0]s } err error opErrContext = ogenerrors.OperationContext{ - Name: "TestResponseStringIpv6NullableArrayArray", - ID: "test_response_string_ipv6_nullable_array_array", + Name: "TestResponseStringMACNullableArrayArray", + ID: "test_response_string_mac_nullable_array_array", } ) - request, close, err := s.decodeTestResponseStringIpv6NullableArrayArrayRequest(r) + request, close, err := s.decodeTestResponseStringMACNullableArrayArrayRequest(r) if err != nil { err = &ogenerrors.DecodeRequestError{ OperationContext: opErrContext, @@ -95371,13 +97252,13 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayArrayRequest(args [0]s } }() - var response [][]NilIPv6 + var response [][]NilHardwareAddr if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, - OperationName: "TestResponseStringIpv6NullableArrayArray", + OperationName: "TestResponseStringMACNullableArrayArray", OperationSummary: "", - OperationID: "test_response_string_ipv6_nullable_array_array", + OperationID: "test_response_string_mac_nullable_array_array", Body: request, Params: middleware.Parameters{}, Raw: r, @@ -95386,7 +97267,7 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayArrayRequest(args [0]s type ( Request = string Params = struct{} - Response = [][]NilIPv6 + Response = [][]NilHardwareAddr ) response, err = middleware.HookMiddleware[ Request, @@ -95397,12 +97278,12 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayArrayRequest(args [0]s mreq, nil, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.TestResponseStringIpv6NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringMACNullableArrayArray(ctx, request) return response, err }, ) } else { - response, err = s.h.TestResponseStringIpv6NullableArrayArray(ctx, request) + response, err = s.h.TestResponseStringMACNullableArrayArray(ctx, request) } if err != nil { recordError("Internal", err) @@ -95410,7 +97291,7 @@ func (s *Server) handleTestResponseStringIpv6NullableArrayArrayRequest(args [0]s return } - if err := encodeTestResponseStringIpv6NullableArrayArrayResponse(response, w, span); err != nil { + if err := encodeTestResponseStringMACNullableArrayArrayResponse(response, w, span); err != nil { recordError("EncodeResponse", err) if !errors.Is(err, ht.ErrInternalServerErrorResponse) { s.cfg.ErrorHandler(ctx, w, r, err) diff --git a/examples/ex_test_format/oas_json_gen.go b/examples/ex_test_format/oas_json_gen.go index 99aaf700d..475098cf6 100644 --- a/examples/ex_test_format/oas_json_gen.go +++ b/examples/ex_test_format/oas_json_gen.go @@ -4,6 +4,7 @@ package api import ( "math/bits" + "net" "net/netip" "net/url" "strconv" @@ -373,6 +374,52 @@ func (s *NilFloat64) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes net.HardwareAddr as json. +func (o NilHardwareAddr) Encode(e *jx.Encoder) { + if o.Null { + e.Null() + return + } + json.EncodeMAC(e, o.Value) +} + +// Decode decodes net.HardwareAddr from json. +func (o *NilHardwareAddr) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode NilHardwareAddr to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v net.HardwareAddr + o.Value = v + o.Null = true + return nil + } + o.Null = false + v, err := json.DecodeMAC(d) + if err != nil { + return err + } + o.Value = v + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NilHardwareAddr) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NilHardwareAddr) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes netip.Addr as json. func (o NilIP) Encode(e *jx.Encoder) { if o.Null { @@ -2285,6 +2332,41 @@ func (s *OptFloat64) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes net.HardwareAddr as json. +func (o OptHardwareAddr) Encode(e *jx.Encoder) { + if !o.Set { + return + } + json.EncodeMAC(e, o.Value) +} + +// Decode decodes net.HardwareAddr from json. +func (o *OptHardwareAddr) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptHardwareAddr to nil") + } + o.Set = true + v, err := json.DecodeMAC(d) + if err != nil { + return err + } + o.Value = v + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptHardwareAddr) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptHardwareAddr) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes netip.Addr as json. func (o OptIP) Encode(e *jx.Encoder) { if !o.Set { @@ -2922,6 +3004,57 @@ func (s *OptNilFloat64) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes net.HardwareAddr as json. +func (o OptNilHardwareAddr) Encode(e *jx.Encoder) { + if !o.Set { + return + } + if o.Null { + e.Null() + return + } + json.EncodeMAC(e, o.Value) +} + +// Decode decodes net.HardwareAddr from json. +func (o *OptNilHardwareAddr) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptNilHardwareAddr to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v net.HardwareAddr + o.Value = v + o.Set = true + o.Null = true + return nil + } + o.Set = true + o.Null = false + v, err := json.DecodeMAC(d) + if err != nil { + return err + } + o.Value = v + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptNilHardwareAddr) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptNilHardwareAddr) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes netip.Addr as json. func (o OptNilIP) Encode(e *jx.Encoder) { if !o.Set { @@ -6288,6 +6421,14 @@ func (s *TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + e.FieldStart("required_array_string_mac") + e.ArrStart() + for _, elem := range s.RequiredArrayStringMAC { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } { e.FieldStart("required_array_string_password") e.ArrStart() @@ -6911,6 +7052,18 @@ func (s *TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + e.FieldStart("required_double_array_string_mac") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayStringMAC { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } { e.FieldStart("required_double_array_string_password") e.ArrStart() @@ -7240,6 +7393,10 @@ func (s *TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { e.FieldStart("required_string_ipv6") json.EncodeIPv6(e, s.RequiredStringIpv6) } + { + e.FieldStart("required_string_mac") + json.EncodeMAC(e, s.RequiredStringMAC) + } { e.FieldStart("required_string_password") e.Str(s.RequiredStringPassword) @@ -7725,6 +7882,16 @@ func (s *TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalArrayStringMAC != nil { + e.FieldStart("optional_array_string_mac") + e.ArrStart() + for _, elem := range s.OptionalArrayStringMAC { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + } { if s.OptionalArrayStringPassword != nil { e.FieldStart("optional_array_string_password") @@ -8462,6 +8629,20 @@ func (s *TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalDoubleArrayStringMAC != nil { + e.FieldStart("optional_double_array_string_mac") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayStringMAC { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } { if s.OptionalDoubleArrayStringPassword != nil { e.FieldStart("optional_double_array_string_password") @@ -8894,6 +9075,12 @@ func (s *TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { s.OptionalStringIpv6.Encode(e) } } + { + if s.OptionalStringMAC.Set { + e.FieldStart("optional_string_mac") + s.OptionalStringMAC.Encode(e) + } + } { if s.OptionalStringPassword.Set { e.FieldStart("optional_string_password") @@ -8980,7 +9167,7 @@ func (s *TestRequestFormatTestReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfTestRequestFormatTestReq = [336]string{ +var jsonFieldsNameOfTestRequestFormatTestReq = [342]string{ 0: "required_any", 1: "required_array_any", 2: "required_array_boolean", @@ -9024,299 +9211,305 @@ var jsonFieldsNameOfTestRequestFormatTestReq = [336]string{ 40: "required_array_string_ip", 41: "required_array_string_ipv4", 42: "required_array_string_ipv6", - 43: "required_array_string_password", - 44: "required_array_string_time", - 45: "required_array_string_uint", - 46: "required_array_string_uint16", - 47: "required_array_string_uint32", - 48: "required_array_string_uint64", - 49: "required_array_string_uint8", - 50: "required_array_string_unix", - 51: "required_array_string_unix-micro", - 52: "required_array_string_unix-milli", - 53: "required_array_string_unix-nano", - 54: "required_array_string_unix-seconds", - 55: "required_array_string_uri", - 56: "required_array_string_uuid", - 57: "required_boolean", - 58: "required_double_array_any", - 59: "required_double_array_boolean", - 60: "required_double_array_integer", - 61: "required_double_array_integer_int16", - 62: "required_double_array_integer_int32", - 63: "required_double_array_integer_int64", - 64: "required_double_array_integer_int8", - 65: "required_double_array_integer_uint", - 66: "required_double_array_integer_uint16", - 67: "required_double_array_integer_uint32", - 68: "required_double_array_integer_uint64", - 69: "required_double_array_integer_uint8", - 70: "required_double_array_integer_unix", - 71: "required_double_array_integer_unix-micro", - 72: "required_double_array_integer_unix-milli", - 73: "required_double_array_integer_unix-nano", - 74: "required_double_array_integer_unix-seconds", - 75: "required_double_array_null", - 76: "required_double_array_number", - 77: "required_double_array_number_double", - 78: "required_double_array_number_float", - 79: "required_double_array_number_int32", - 80: "required_double_array_number_int64", - 81: "required_double_array_string", - 82: "required_double_array_string_base64", - 83: "required_double_array_string_binary", - 84: "required_double_array_string_byte", - 85: "required_double_array_string_date", - 86: "required_double_array_string_date-time", - 87: "required_double_array_string_duration", - 88: "required_double_array_string_email", - 89: "required_double_array_string_float32", - 90: "required_double_array_string_float64", - 91: "required_double_array_string_hostname", - 92: "required_double_array_string_int", - 93: "required_double_array_string_int16", - 94: "required_double_array_string_int32", - 95: "required_double_array_string_int64", - 96: "required_double_array_string_int8", - 97: "required_double_array_string_ip", - 98: "required_double_array_string_ipv4", - 99: "required_double_array_string_ipv6", - 100: "required_double_array_string_password", - 101: "required_double_array_string_time", - 102: "required_double_array_string_uint", - 103: "required_double_array_string_uint16", - 104: "required_double_array_string_uint32", - 105: "required_double_array_string_uint64", - 106: "required_double_array_string_uint8", - 107: "required_double_array_string_unix", - 108: "required_double_array_string_unix-micro", - 109: "required_double_array_string_unix-milli", - 110: "required_double_array_string_unix-nano", - 111: "required_double_array_string_unix-seconds", - 112: "required_double_array_string_uri", - 113: "required_double_array_string_uuid", - 114: "required_integer", - 115: "required_integer_int16", - 116: "required_integer_int32", - 117: "required_integer_int64", - 118: "required_integer_int8", - 119: "required_integer_uint", - 120: "required_integer_uint16", - 121: "required_integer_uint32", - 122: "required_integer_uint64", - 123: "required_integer_uint8", - 124: "required_integer_unix", - 125: "required_integer_unix-micro", - 126: "required_integer_unix-milli", - 127: "required_integer_unix-nano", - 128: "required_integer_unix-seconds", - 129: "required_null", - 130: "required_number", - 131: "required_number_double", - 132: "required_number_float", - 133: "required_number_int32", - 134: "required_number_int64", - 135: "required_string", - 136: "required_string_base64", - 137: "required_string_binary", - 138: "required_string_byte", - 139: "required_string_date", - 140: "required_string_date-time", - 141: "required_string_duration", - 142: "required_string_email", - 143: "required_string_float32", - 144: "required_string_float64", - 145: "required_string_hostname", - 146: "required_string_int", - 147: "required_string_int16", - 148: "required_string_int32", - 149: "required_string_int64", - 150: "required_string_int8", - 151: "required_string_ip", - 152: "required_string_ipv4", - 153: "required_string_ipv6", - 154: "required_string_password", - 155: "required_string_time", - 156: "required_string_uint", - 157: "required_string_uint16", - 158: "required_string_uint32", - 159: "required_string_uint64", - 160: "required_string_uint8", - 161: "required_string_unix", - 162: "required_string_unix-micro", - 163: "required_string_unix-milli", - 164: "required_string_unix-nano", - 165: "required_string_unix-seconds", - 166: "required_string_uri", - 167: "required_string_uuid", - 168: "optional_any", - 169: "optional_array_any", - 170: "optional_array_boolean", - 171: "optional_array_integer", - 172: "optional_array_integer_int16", - 173: "optional_array_integer_int32", - 174: "optional_array_integer_int64", - 175: "optional_array_integer_int8", - 176: "optional_array_integer_uint", - 177: "optional_array_integer_uint16", - 178: "optional_array_integer_uint32", - 179: "optional_array_integer_uint64", - 180: "optional_array_integer_uint8", - 181: "optional_array_integer_unix", - 182: "optional_array_integer_unix-micro", - 183: "optional_array_integer_unix-milli", - 184: "optional_array_integer_unix-nano", - 185: "optional_array_integer_unix-seconds", - 186: "optional_array_null", - 187: "optional_array_number", - 188: "optional_array_number_double", - 189: "optional_array_number_float", - 190: "optional_array_number_int32", - 191: "optional_array_number_int64", - 192: "optional_array_string", - 193: "optional_array_string_base64", - 194: "optional_array_string_binary", - 195: "optional_array_string_byte", - 196: "optional_array_string_date", - 197: "optional_array_string_date-time", - 198: "optional_array_string_duration", - 199: "optional_array_string_email", - 200: "optional_array_string_float32", - 201: "optional_array_string_float64", - 202: "optional_array_string_hostname", - 203: "optional_array_string_int", - 204: "optional_array_string_int16", - 205: "optional_array_string_int32", - 206: "optional_array_string_int64", - 207: "optional_array_string_int8", - 208: "optional_array_string_ip", - 209: "optional_array_string_ipv4", - 210: "optional_array_string_ipv6", - 211: "optional_array_string_password", - 212: "optional_array_string_time", - 213: "optional_array_string_uint", - 214: "optional_array_string_uint16", - 215: "optional_array_string_uint32", - 216: "optional_array_string_uint64", - 217: "optional_array_string_uint8", - 218: "optional_array_string_unix", - 219: "optional_array_string_unix-micro", - 220: "optional_array_string_unix-milli", - 221: "optional_array_string_unix-nano", - 222: "optional_array_string_unix-seconds", - 223: "optional_array_string_uri", - 224: "optional_array_string_uuid", - 225: "optional_boolean", - 226: "optional_double_array_any", - 227: "optional_double_array_boolean", - 228: "optional_double_array_integer", - 229: "optional_double_array_integer_int16", - 230: "optional_double_array_integer_int32", - 231: "optional_double_array_integer_int64", - 232: "optional_double_array_integer_int8", - 233: "optional_double_array_integer_uint", - 234: "optional_double_array_integer_uint16", - 235: "optional_double_array_integer_uint32", - 236: "optional_double_array_integer_uint64", - 237: "optional_double_array_integer_uint8", - 238: "optional_double_array_integer_unix", - 239: "optional_double_array_integer_unix-micro", - 240: "optional_double_array_integer_unix-milli", - 241: "optional_double_array_integer_unix-nano", - 242: "optional_double_array_integer_unix-seconds", - 243: "optional_double_array_null", - 244: "optional_double_array_number", - 245: "optional_double_array_number_double", - 246: "optional_double_array_number_float", - 247: "optional_double_array_number_int32", - 248: "optional_double_array_number_int64", - 249: "optional_double_array_string", - 250: "optional_double_array_string_base64", - 251: "optional_double_array_string_binary", - 252: "optional_double_array_string_byte", - 253: "optional_double_array_string_date", - 254: "optional_double_array_string_date-time", - 255: "optional_double_array_string_duration", - 256: "optional_double_array_string_email", - 257: "optional_double_array_string_float32", - 258: "optional_double_array_string_float64", - 259: "optional_double_array_string_hostname", - 260: "optional_double_array_string_int", - 261: "optional_double_array_string_int16", - 262: "optional_double_array_string_int32", - 263: "optional_double_array_string_int64", - 264: "optional_double_array_string_int8", - 265: "optional_double_array_string_ip", - 266: "optional_double_array_string_ipv4", - 267: "optional_double_array_string_ipv6", - 268: "optional_double_array_string_password", - 269: "optional_double_array_string_time", - 270: "optional_double_array_string_uint", - 271: "optional_double_array_string_uint16", - 272: "optional_double_array_string_uint32", - 273: "optional_double_array_string_uint64", - 274: "optional_double_array_string_uint8", - 275: "optional_double_array_string_unix", - 276: "optional_double_array_string_unix-micro", - 277: "optional_double_array_string_unix-milli", - 278: "optional_double_array_string_unix-nano", - 279: "optional_double_array_string_unix-seconds", - 280: "optional_double_array_string_uri", - 281: "optional_double_array_string_uuid", - 282: "optional_integer", - 283: "optional_integer_int16", - 284: "optional_integer_int32", - 285: "optional_integer_int64", - 286: "optional_integer_int8", - 287: "optional_integer_uint", - 288: "optional_integer_uint16", - 289: "optional_integer_uint32", - 290: "optional_integer_uint64", - 291: "optional_integer_uint8", - 292: "optional_integer_unix", - 293: "optional_integer_unix-micro", - 294: "optional_integer_unix-milli", - 295: "optional_integer_unix-nano", - 296: "optional_integer_unix-seconds", - 297: "optional_null", - 298: "optional_number", - 299: "optional_number_double", - 300: "optional_number_float", - 301: "optional_number_int32", - 302: "optional_number_int64", - 303: "optional_string", - 304: "optional_string_base64", - 305: "optional_string_binary", - 306: "optional_string_byte", - 307: "optional_string_date", - 308: "optional_string_date-time", - 309: "optional_string_duration", - 310: "optional_string_email", - 311: "optional_string_float32", - 312: "optional_string_float64", - 313: "optional_string_hostname", - 314: "optional_string_int", - 315: "optional_string_int16", - 316: "optional_string_int32", - 317: "optional_string_int64", - 318: "optional_string_int8", - 319: "optional_string_ip", - 320: "optional_string_ipv4", - 321: "optional_string_ipv6", - 322: "optional_string_password", - 323: "optional_string_time", - 324: "optional_string_uint", - 325: "optional_string_uint16", - 326: "optional_string_uint32", - 327: "optional_string_uint64", - 328: "optional_string_uint8", - 329: "optional_string_unix", - 330: "optional_string_unix-micro", - 331: "optional_string_unix-milli", - 332: "optional_string_unix-nano", - 333: "optional_string_unix-seconds", - 334: "optional_string_uri", - 335: "optional_string_uuid", + 43: "required_array_string_mac", + 44: "required_array_string_password", + 45: "required_array_string_time", + 46: "required_array_string_uint", + 47: "required_array_string_uint16", + 48: "required_array_string_uint32", + 49: "required_array_string_uint64", + 50: "required_array_string_uint8", + 51: "required_array_string_unix", + 52: "required_array_string_unix-micro", + 53: "required_array_string_unix-milli", + 54: "required_array_string_unix-nano", + 55: "required_array_string_unix-seconds", + 56: "required_array_string_uri", + 57: "required_array_string_uuid", + 58: "required_boolean", + 59: "required_double_array_any", + 60: "required_double_array_boolean", + 61: "required_double_array_integer", + 62: "required_double_array_integer_int16", + 63: "required_double_array_integer_int32", + 64: "required_double_array_integer_int64", + 65: "required_double_array_integer_int8", + 66: "required_double_array_integer_uint", + 67: "required_double_array_integer_uint16", + 68: "required_double_array_integer_uint32", + 69: "required_double_array_integer_uint64", + 70: "required_double_array_integer_uint8", + 71: "required_double_array_integer_unix", + 72: "required_double_array_integer_unix-micro", + 73: "required_double_array_integer_unix-milli", + 74: "required_double_array_integer_unix-nano", + 75: "required_double_array_integer_unix-seconds", + 76: "required_double_array_null", + 77: "required_double_array_number", + 78: "required_double_array_number_double", + 79: "required_double_array_number_float", + 80: "required_double_array_number_int32", + 81: "required_double_array_number_int64", + 82: "required_double_array_string", + 83: "required_double_array_string_base64", + 84: "required_double_array_string_binary", + 85: "required_double_array_string_byte", + 86: "required_double_array_string_date", + 87: "required_double_array_string_date-time", + 88: "required_double_array_string_duration", + 89: "required_double_array_string_email", + 90: "required_double_array_string_float32", + 91: "required_double_array_string_float64", + 92: "required_double_array_string_hostname", + 93: "required_double_array_string_int", + 94: "required_double_array_string_int16", + 95: "required_double_array_string_int32", + 96: "required_double_array_string_int64", + 97: "required_double_array_string_int8", + 98: "required_double_array_string_ip", + 99: "required_double_array_string_ipv4", + 100: "required_double_array_string_ipv6", + 101: "required_double_array_string_mac", + 102: "required_double_array_string_password", + 103: "required_double_array_string_time", + 104: "required_double_array_string_uint", + 105: "required_double_array_string_uint16", + 106: "required_double_array_string_uint32", + 107: "required_double_array_string_uint64", + 108: "required_double_array_string_uint8", + 109: "required_double_array_string_unix", + 110: "required_double_array_string_unix-micro", + 111: "required_double_array_string_unix-milli", + 112: "required_double_array_string_unix-nano", + 113: "required_double_array_string_unix-seconds", + 114: "required_double_array_string_uri", + 115: "required_double_array_string_uuid", + 116: "required_integer", + 117: "required_integer_int16", + 118: "required_integer_int32", + 119: "required_integer_int64", + 120: "required_integer_int8", + 121: "required_integer_uint", + 122: "required_integer_uint16", + 123: "required_integer_uint32", + 124: "required_integer_uint64", + 125: "required_integer_uint8", + 126: "required_integer_unix", + 127: "required_integer_unix-micro", + 128: "required_integer_unix-milli", + 129: "required_integer_unix-nano", + 130: "required_integer_unix-seconds", + 131: "required_null", + 132: "required_number", + 133: "required_number_double", + 134: "required_number_float", + 135: "required_number_int32", + 136: "required_number_int64", + 137: "required_string", + 138: "required_string_base64", + 139: "required_string_binary", + 140: "required_string_byte", + 141: "required_string_date", + 142: "required_string_date-time", + 143: "required_string_duration", + 144: "required_string_email", + 145: "required_string_float32", + 146: "required_string_float64", + 147: "required_string_hostname", + 148: "required_string_int", + 149: "required_string_int16", + 150: "required_string_int32", + 151: "required_string_int64", + 152: "required_string_int8", + 153: "required_string_ip", + 154: "required_string_ipv4", + 155: "required_string_ipv6", + 156: "required_string_mac", + 157: "required_string_password", + 158: "required_string_time", + 159: "required_string_uint", + 160: "required_string_uint16", + 161: "required_string_uint32", + 162: "required_string_uint64", + 163: "required_string_uint8", + 164: "required_string_unix", + 165: "required_string_unix-micro", + 166: "required_string_unix-milli", + 167: "required_string_unix-nano", + 168: "required_string_unix-seconds", + 169: "required_string_uri", + 170: "required_string_uuid", + 171: "optional_any", + 172: "optional_array_any", + 173: "optional_array_boolean", + 174: "optional_array_integer", + 175: "optional_array_integer_int16", + 176: "optional_array_integer_int32", + 177: "optional_array_integer_int64", + 178: "optional_array_integer_int8", + 179: "optional_array_integer_uint", + 180: "optional_array_integer_uint16", + 181: "optional_array_integer_uint32", + 182: "optional_array_integer_uint64", + 183: "optional_array_integer_uint8", + 184: "optional_array_integer_unix", + 185: "optional_array_integer_unix-micro", + 186: "optional_array_integer_unix-milli", + 187: "optional_array_integer_unix-nano", + 188: "optional_array_integer_unix-seconds", + 189: "optional_array_null", + 190: "optional_array_number", + 191: "optional_array_number_double", + 192: "optional_array_number_float", + 193: "optional_array_number_int32", + 194: "optional_array_number_int64", + 195: "optional_array_string", + 196: "optional_array_string_base64", + 197: "optional_array_string_binary", + 198: "optional_array_string_byte", + 199: "optional_array_string_date", + 200: "optional_array_string_date-time", + 201: "optional_array_string_duration", + 202: "optional_array_string_email", + 203: "optional_array_string_float32", + 204: "optional_array_string_float64", + 205: "optional_array_string_hostname", + 206: "optional_array_string_int", + 207: "optional_array_string_int16", + 208: "optional_array_string_int32", + 209: "optional_array_string_int64", + 210: "optional_array_string_int8", + 211: "optional_array_string_ip", + 212: "optional_array_string_ipv4", + 213: "optional_array_string_ipv6", + 214: "optional_array_string_mac", + 215: "optional_array_string_password", + 216: "optional_array_string_time", + 217: "optional_array_string_uint", + 218: "optional_array_string_uint16", + 219: "optional_array_string_uint32", + 220: "optional_array_string_uint64", + 221: "optional_array_string_uint8", + 222: "optional_array_string_unix", + 223: "optional_array_string_unix-micro", + 224: "optional_array_string_unix-milli", + 225: "optional_array_string_unix-nano", + 226: "optional_array_string_unix-seconds", + 227: "optional_array_string_uri", + 228: "optional_array_string_uuid", + 229: "optional_boolean", + 230: "optional_double_array_any", + 231: "optional_double_array_boolean", + 232: "optional_double_array_integer", + 233: "optional_double_array_integer_int16", + 234: "optional_double_array_integer_int32", + 235: "optional_double_array_integer_int64", + 236: "optional_double_array_integer_int8", + 237: "optional_double_array_integer_uint", + 238: "optional_double_array_integer_uint16", + 239: "optional_double_array_integer_uint32", + 240: "optional_double_array_integer_uint64", + 241: "optional_double_array_integer_uint8", + 242: "optional_double_array_integer_unix", + 243: "optional_double_array_integer_unix-micro", + 244: "optional_double_array_integer_unix-milli", + 245: "optional_double_array_integer_unix-nano", + 246: "optional_double_array_integer_unix-seconds", + 247: "optional_double_array_null", + 248: "optional_double_array_number", + 249: "optional_double_array_number_double", + 250: "optional_double_array_number_float", + 251: "optional_double_array_number_int32", + 252: "optional_double_array_number_int64", + 253: "optional_double_array_string", + 254: "optional_double_array_string_base64", + 255: "optional_double_array_string_binary", + 256: "optional_double_array_string_byte", + 257: "optional_double_array_string_date", + 258: "optional_double_array_string_date-time", + 259: "optional_double_array_string_duration", + 260: "optional_double_array_string_email", + 261: "optional_double_array_string_float32", + 262: "optional_double_array_string_float64", + 263: "optional_double_array_string_hostname", + 264: "optional_double_array_string_int", + 265: "optional_double_array_string_int16", + 266: "optional_double_array_string_int32", + 267: "optional_double_array_string_int64", + 268: "optional_double_array_string_int8", + 269: "optional_double_array_string_ip", + 270: "optional_double_array_string_ipv4", + 271: "optional_double_array_string_ipv6", + 272: "optional_double_array_string_mac", + 273: "optional_double_array_string_password", + 274: "optional_double_array_string_time", + 275: "optional_double_array_string_uint", + 276: "optional_double_array_string_uint16", + 277: "optional_double_array_string_uint32", + 278: "optional_double_array_string_uint64", + 279: "optional_double_array_string_uint8", + 280: "optional_double_array_string_unix", + 281: "optional_double_array_string_unix-micro", + 282: "optional_double_array_string_unix-milli", + 283: "optional_double_array_string_unix-nano", + 284: "optional_double_array_string_unix-seconds", + 285: "optional_double_array_string_uri", + 286: "optional_double_array_string_uuid", + 287: "optional_integer", + 288: "optional_integer_int16", + 289: "optional_integer_int32", + 290: "optional_integer_int64", + 291: "optional_integer_int8", + 292: "optional_integer_uint", + 293: "optional_integer_uint16", + 294: "optional_integer_uint32", + 295: "optional_integer_uint64", + 296: "optional_integer_uint8", + 297: "optional_integer_unix", + 298: "optional_integer_unix-micro", + 299: "optional_integer_unix-milli", + 300: "optional_integer_unix-nano", + 301: "optional_integer_unix-seconds", + 302: "optional_null", + 303: "optional_number", + 304: "optional_number_double", + 305: "optional_number_float", + 306: "optional_number_int32", + 307: "optional_number_int64", + 308: "optional_string", + 309: "optional_string_base64", + 310: "optional_string_binary", + 311: "optional_string_byte", + 312: "optional_string_date", + 313: "optional_string_date-time", + 314: "optional_string_duration", + 315: "optional_string_email", + 316: "optional_string_float32", + 317: "optional_string_float64", + 318: "optional_string_hostname", + 319: "optional_string_int", + 320: "optional_string_int16", + 321: "optional_string_int32", + 322: "optional_string_int64", + 323: "optional_string_int8", + 324: "optional_string_ip", + 325: "optional_string_ipv4", + 326: "optional_string_ipv6", + 327: "optional_string_mac", + 328: "optional_string_password", + 329: "optional_string_time", + 330: "optional_string_uint", + 331: "optional_string_uint16", + 332: "optional_string_uint32", + 333: "optional_string_uint64", + 334: "optional_string_uint8", + 335: "optional_string_unix", + 336: "optional_string_unix-micro", + 337: "optional_string_unix-milli", + 338: "optional_string_unix-nano", + 339: "optional_string_unix-seconds", + 340: "optional_string_uri", + 341: "optional_string_uuid", } // Decode decodes TestRequestFormatTestReq from json. @@ -9324,7 +9517,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode TestRequestFormatTestReq to nil") } - var requiredBitSet [42]uint8 + var requiredBitSet [43]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -10178,8 +10371,28 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_array_string_ipv6\"") } - case "required_array_string_password": + case "required_array_string_mac": requiredBitSet[5] |= 1 << 3 + if err := func() error { + s.RequiredArrayStringMAC = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { + return err + } + s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_string_mac\"") + } + case "required_array_string_password": + requiredBitSet[5] |= 1 << 4 if err := func() error { s.RequiredArrayStringPassword = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10199,7 +10412,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[5] |= 1 << 4 + requiredBitSet[5] |= 1 << 5 if err := func() error { s.RequiredArrayStringTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10219,7 +10432,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_time\"") } case "required_array_string_uint": - requiredBitSet[5] |= 1 << 5 + requiredBitSet[5] |= 1 << 6 if err := func() error { s.RequiredArrayStringUint = make([]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10239,7 +10452,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint\"") } case "required_array_string_uint16": - requiredBitSet[5] |= 1 << 6 + requiredBitSet[5] |= 1 << 7 if err := func() error { s.RequiredArrayStringUint16 = make([]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10259,7 +10472,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint16\"") } case "required_array_string_uint32": - requiredBitSet[5] |= 1 << 7 + requiredBitSet[6] |= 1 << 0 if err := func() error { s.RequiredArrayStringUint32 = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10279,7 +10492,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint32\"") } case "required_array_string_uint64": - requiredBitSet[6] |= 1 << 0 + requiredBitSet[6] |= 1 << 1 if err := func() error { s.RequiredArrayStringUint64 = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10299,7 +10512,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint64\"") } case "required_array_string_uint8": - requiredBitSet[6] |= 1 << 1 + requiredBitSet[6] |= 1 << 2 if err := func() error { s.RequiredArrayStringUint8 = make([]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10319,7 +10532,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint8\"") } case "required_array_string_unix": - requiredBitSet[6] |= 1 << 2 + requiredBitSet[6] |= 1 << 3 if err := func() error { s.RequiredArrayStringUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10339,7 +10552,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[6] |= 1 << 3 + requiredBitSet[6] |= 1 << 4 if err := func() error { s.RequiredArrayStringUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10359,7 +10572,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[6] |= 1 << 4 + requiredBitSet[6] |= 1 << 5 if err := func() error { s.RequiredArrayStringUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10379,7 +10592,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[6] |= 1 << 5 + requiredBitSet[6] |= 1 << 6 if err := func() error { s.RequiredArrayStringUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10399,7 +10612,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[6] |= 1 << 6 + requiredBitSet[6] |= 1 << 7 if err := func() error { s.RequiredArrayStringUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10419,7 +10632,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[6] |= 1 << 7 + requiredBitSet[7] |= 1 << 0 if err := func() error { s.RequiredArrayStringURI = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10439,7 +10652,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[7] |= 1 << 0 + requiredBitSet[7] |= 1 << 1 if err := func() error { s.RequiredArrayStringUUID = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10459,7 +10672,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uuid\"") } case "required_boolean": - requiredBitSet[7] |= 1 << 1 + requiredBitSet[7] |= 1 << 2 if err := func() error { v, err := d.Bool() s.RequiredBoolean = bool(v) @@ -10471,7 +10684,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_boolean\"") } case "required_double_array_any": - requiredBitSet[7] |= 1 << 2 + requiredBitSet[7] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayAny = make([][]jx.Raw, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10499,7 +10712,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[7] |= 1 << 3 + requiredBitSet[7] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayBoolean = make([][]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10527,7 +10740,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[7] |= 1 << 4 + requiredBitSet[7] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayInteger = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10555,7 +10768,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer\"") } case "required_double_array_integer_int16": - requiredBitSet[7] |= 1 << 5 + requiredBitSet[7] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerInt16 = make([][]int16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10583,7 +10796,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int16\"") } case "required_double_array_integer_int32": - requiredBitSet[7] |= 1 << 6 + requiredBitSet[7] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10611,7 +10824,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[7] |= 1 << 7 + requiredBitSet[8] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayIntegerInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10639,7 +10852,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int64\"") } case "required_double_array_integer_int8": - requiredBitSet[8] |= 1 << 0 + requiredBitSet[8] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayIntegerInt8 = make([][]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10667,7 +10880,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int8\"") } case "required_double_array_integer_uint": - requiredBitSet[8] |= 1 << 1 + requiredBitSet[8] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayIntegerUint = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10695,7 +10908,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint\"") } case "required_double_array_integer_uint16": - requiredBitSet[8] |= 1 << 2 + requiredBitSet[8] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUint16 = make([][]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10723,7 +10936,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint16\"") } case "required_double_array_integer_uint32": - requiredBitSet[8] |= 1 << 3 + requiredBitSet[8] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayIntegerUint32 = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10751,7 +10964,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint32\"") } case "required_double_array_integer_uint64": - requiredBitSet[8] |= 1 << 4 + requiredBitSet[8] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayIntegerUint64 = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10779,7 +10992,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint64\"") } case "required_double_array_integer_uint8": - requiredBitSet[8] |= 1 << 5 + requiredBitSet[8] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerUint8 = make([][]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10807,7 +11020,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint8\"") } case "required_double_array_integer_unix": - requiredBitSet[8] |= 1 << 6 + requiredBitSet[8] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10835,7 +11048,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[8] |= 1 << 7 + requiredBitSet[9] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10863,7 +11076,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[9] |= 1 << 0 + requiredBitSet[9] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10891,7 +11104,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[9] |= 1 << 1 + requiredBitSet[9] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10919,7 +11132,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[9] |= 1 << 2 + requiredBitSet[9] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10947,7 +11160,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[9] |= 1 << 3 + requiredBitSet[9] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayNull = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -10973,7 +11186,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[9] |= 1 << 4 + requiredBitSet[9] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayNumber = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11001,7 +11214,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[9] |= 1 << 5 + requiredBitSet[9] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayNumberDouble = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11029,7 +11242,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[9] |= 1 << 6 + requiredBitSet[9] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayNumberFloat = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11057,7 +11270,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[9] |= 1 << 7 + requiredBitSet[10] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayNumberInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11085,7 +11298,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[10] |= 1 << 0 + requiredBitSet[10] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayNumberInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11113,7 +11326,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[10] |= 1 << 1 + requiredBitSet[10] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayString = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11141,7 +11354,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string\"") } case "required_double_array_string_base64": - requiredBitSet[10] |= 1 << 2 + requiredBitSet[10] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringBase64 = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11169,7 +11382,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_base64\"") } case "required_double_array_string_binary": - requiredBitSet[10] |= 1 << 3 + requiredBitSet[10] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringBinary = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11197,7 +11410,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[10] |= 1 << 4 + requiredBitSet[10] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringByte = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11225,7 +11438,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[10] |= 1 << 5 + requiredBitSet[10] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringDate = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11253,7 +11466,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[10] |= 1 << 6 + requiredBitSet[10] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringDateMinusTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11281,7 +11494,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[10] |= 1 << 7 + requiredBitSet[11] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringDuration = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11309,7 +11522,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[11] |= 1 << 0 + requiredBitSet[11] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringEmail = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11337,7 +11550,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_float32": - requiredBitSet[11] |= 1 << 1 + requiredBitSet[11] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringFloat32 = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11365,7 +11578,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_float32\"") } case "required_double_array_string_float64": - requiredBitSet[11] |= 1 << 2 + requiredBitSet[11] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringFloat64 = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11393,7 +11606,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_float64\"") } case "required_double_array_string_hostname": - requiredBitSet[11] |= 1 << 3 + requiredBitSet[11] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringHostname = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11421,7 +11634,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_int": - requiredBitSet[11] |= 1 << 4 + requiredBitSet[11] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringInt = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11449,7 +11662,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int\"") } case "required_double_array_string_int16": - requiredBitSet[11] |= 1 << 5 + requiredBitSet[11] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringInt16 = make([][]int16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11477,7 +11690,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int16\"") } case "required_double_array_string_int32": - requiredBitSet[11] |= 1 << 6 + requiredBitSet[11] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11505,7 +11718,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[11] |= 1 << 7 + requiredBitSet[12] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11533,7 +11746,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_int8": - requiredBitSet[12] |= 1 << 0 + requiredBitSet[12] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringInt8 = make([][]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11561,7 +11774,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int8\"") } case "required_double_array_string_ip": - requiredBitSet[12] |= 1 << 1 + requiredBitSet[12] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringIP = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11589,7 +11802,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[12] |= 1 << 2 + requiredBitSet[12] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringIpv4 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11617,7 +11830,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[12] |= 1 << 3 + requiredBitSet[12] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringIpv6 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11644,8 +11857,36 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_double_array_string_ipv6\"") } + case "required_double_array_string_mac": + requiredBitSet[12] |= 1 << 5 + if err := func() error { + s.RequiredDoubleArrayStringMAC = make([][]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayStringMAC = append(s.RequiredDoubleArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_string_mac\"") + } case "required_double_array_string_password": - requiredBitSet[12] |= 1 << 4 + requiredBitSet[12] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringPassword = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11673,7 +11914,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[12] |= 1 << 5 + requiredBitSet[12] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11701,7 +11942,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_uint": - requiredBitSet[12] |= 1 << 6 + requiredBitSet[13] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUint = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11729,7 +11970,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint\"") } case "required_double_array_string_uint16": - requiredBitSet[12] |= 1 << 7 + requiredBitSet[13] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUint16 = make([][]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11757,7 +11998,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint16\"") } case "required_double_array_string_uint32": - requiredBitSet[13] |= 1 << 0 + requiredBitSet[13] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringUint32 = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11785,7 +12026,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint32\"") } case "required_double_array_string_uint64": - requiredBitSet[13] |= 1 << 1 + requiredBitSet[13] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUint64 = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11813,7 +12054,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint64\"") } case "required_double_array_string_uint8": - requiredBitSet[13] |= 1 << 2 + requiredBitSet[13] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringUint8 = make([][]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11841,7 +12082,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint8\"") } case "required_double_array_string_unix": - requiredBitSet[13] |= 1 << 3 + requiredBitSet[13] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11869,7 +12110,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[13] |= 1 << 4 + requiredBitSet[13] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11897,7 +12138,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[13] |= 1 << 5 + requiredBitSet[13] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11925,7 +12166,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[13] |= 1 << 6 + requiredBitSet[14] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11953,7 +12194,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[13] |= 1 << 7 + requiredBitSet[14] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -11981,7 +12222,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[14] |= 1 << 0 + requiredBitSet[14] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringURI = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -12009,7 +12250,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[14] |= 1 << 1 + requiredBitSet[14] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUUID = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -12037,7 +12278,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uuid\"") } case "required_integer": - requiredBitSet[14] |= 1 << 2 + requiredBitSet[14] |= 1 << 4 if err := func() error { v, err := d.Int() s.RequiredInteger = int(v) @@ -12049,7 +12290,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer\"") } case "required_integer_int16": - requiredBitSet[14] |= 1 << 3 + requiredBitSet[14] |= 1 << 5 if err := func() error { v, err := d.Int16() s.RequiredIntegerInt16 = int16(v) @@ -12061,7 +12302,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int16\"") } case "required_integer_int32": - requiredBitSet[14] |= 1 << 4 + requiredBitSet[14] |= 1 << 6 if err := func() error { v, err := d.Int32() s.RequiredIntegerInt32 = int32(v) @@ -12073,7 +12314,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int32\"") } case "required_integer_int64": - requiredBitSet[14] |= 1 << 5 + requiredBitSet[14] |= 1 << 7 if err := func() error { v, err := d.Int64() s.RequiredIntegerInt64 = int64(v) @@ -12085,7 +12326,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int64\"") } case "required_integer_int8": - requiredBitSet[14] |= 1 << 6 + requiredBitSet[15] |= 1 << 0 if err := func() error { v, err := d.Int8() s.RequiredIntegerInt8 = int8(v) @@ -12097,7 +12338,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int8\"") } case "required_integer_uint": - requiredBitSet[14] |= 1 << 7 + requiredBitSet[15] |= 1 << 1 if err := func() error { v, err := d.UInt() s.RequiredIntegerUint = uint(v) @@ -12109,7 +12350,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint\"") } case "required_integer_uint16": - requiredBitSet[15] |= 1 << 0 + requiredBitSet[15] |= 1 << 2 if err := func() error { v, err := d.UInt16() s.RequiredIntegerUint16 = uint16(v) @@ -12121,7 +12362,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint16\"") } case "required_integer_uint32": - requiredBitSet[15] |= 1 << 1 + requiredBitSet[15] |= 1 << 3 if err := func() error { v, err := d.UInt32() s.RequiredIntegerUint32 = uint32(v) @@ -12133,7 +12374,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint32\"") } case "required_integer_uint64": - requiredBitSet[15] |= 1 << 2 + requiredBitSet[15] |= 1 << 4 if err := func() error { v, err := d.UInt64() s.RequiredIntegerUint64 = uint64(v) @@ -12145,7 +12386,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint64\"") } case "required_integer_uint8": - requiredBitSet[15] |= 1 << 3 + requiredBitSet[15] |= 1 << 5 if err := func() error { v, err := d.UInt8() s.RequiredIntegerUint8 = uint8(v) @@ -12157,7 +12398,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint8\"") } case "required_integer_unix": - requiredBitSet[15] |= 1 << 4 + requiredBitSet[15] |= 1 << 6 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnix = v @@ -12169,7 +12410,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix\"") } case "required_integer_unix-micro": - requiredBitSet[15] |= 1 << 5 + requiredBitSet[15] |= 1 << 7 if err := func() error { v, err := json.DecodeUnixMicro(d) s.RequiredIntegerUnixMinusMicro = v @@ -12181,7 +12422,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[15] |= 1 << 6 + requiredBitSet[16] |= 1 << 0 if err := func() error { v, err := json.DecodeUnixMilli(d) s.RequiredIntegerUnixMinusMilli = v @@ -12193,7 +12434,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[15] |= 1 << 7 + requiredBitSet[16] |= 1 << 1 if err := func() error { v, err := json.DecodeUnixNano(d) s.RequiredIntegerUnixMinusNano = v @@ -12205,7 +12446,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[16] |= 1 << 0 + requiredBitSet[16] |= 1 << 2 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnixMinusSeconds = v @@ -12217,7 +12458,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-seconds\"") } case "required_null": - requiredBitSet[16] |= 1 << 1 + requiredBitSet[16] |= 1 << 3 if err := func() error { if err := d.Null(); err != nil { return err @@ -12227,7 +12468,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_null\"") } case "required_number": - requiredBitSet[16] |= 1 << 2 + requiredBitSet[16] |= 1 << 4 if err := func() error { v, err := d.Float64() s.RequiredNumber = float64(v) @@ -12239,7 +12480,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number\"") } case "required_number_double": - requiredBitSet[16] |= 1 << 3 + requiredBitSet[16] |= 1 << 5 if err := func() error { v, err := d.Float64() s.RequiredNumberDouble = float64(v) @@ -12251,7 +12492,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_double\"") } case "required_number_float": - requiredBitSet[16] |= 1 << 4 + requiredBitSet[16] |= 1 << 6 if err := func() error { v, err := d.Float32() s.RequiredNumberFloat = float32(v) @@ -12263,7 +12504,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_float\"") } case "required_number_int32": - requiredBitSet[16] |= 1 << 5 + requiredBitSet[16] |= 1 << 7 if err := func() error { v, err := d.Int32() s.RequiredNumberInt32 = int32(v) @@ -12275,7 +12516,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int32\"") } case "required_number_int64": - requiredBitSet[16] |= 1 << 6 + requiredBitSet[17] |= 1 << 0 if err := func() error { v, err := d.Int64() s.RequiredNumberInt64 = int64(v) @@ -12287,7 +12528,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int64\"") } case "required_string": - requiredBitSet[16] |= 1 << 7 + requiredBitSet[17] |= 1 << 1 if err := func() error { v, err := d.Str() s.RequiredString = string(v) @@ -12299,7 +12540,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string\"") } case "required_string_base64": - requiredBitSet[17] |= 1 << 0 + requiredBitSet[17] |= 1 << 2 if err := func() error { v, err := d.Base64() s.RequiredStringBase64 = []byte(v) @@ -12311,7 +12552,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_base64\"") } case "required_string_binary": - requiredBitSet[17] |= 1 << 1 + requiredBitSet[17] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringBinary = string(v) @@ -12323,7 +12564,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_binary\"") } case "required_string_byte": - requiredBitSet[17] |= 1 << 2 + requiredBitSet[17] |= 1 << 4 if err := func() error { v, err := d.Base64() s.RequiredStringByte = []byte(v) @@ -12335,7 +12576,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_byte\"") } case "required_string_date": - requiredBitSet[17] |= 1 << 3 + requiredBitSet[17] |= 1 << 5 if err := func() error { v, err := json.DecodeDate(d) s.RequiredStringDate = v @@ -12347,7 +12588,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date\"") } case "required_string_date-time": - requiredBitSet[17] |= 1 << 4 + requiredBitSet[17] |= 1 << 6 if err := func() error { v, err := json.DecodeDateTime(d) s.RequiredStringDateMinusTime = v @@ -12359,7 +12600,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date-time\"") } case "required_string_duration": - requiredBitSet[17] |= 1 << 5 + requiredBitSet[17] |= 1 << 7 if err := func() error { v, err := json.DecodeDuration(d) s.RequiredStringDuration = v @@ -12371,7 +12612,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_duration\"") } case "required_string_email": - requiredBitSet[17] |= 1 << 6 + requiredBitSet[18] |= 1 << 0 if err := func() error { v, err := d.Str() s.RequiredStringEmail = string(v) @@ -12383,7 +12624,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_email\"") } case "required_string_float32": - requiredBitSet[17] |= 1 << 7 + requiredBitSet[18] |= 1 << 1 if err := func() error { v, err := json.DecodeStringFloat32(d) s.RequiredStringFloat32 = v @@ -12395,7 +12636,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_float32\"") } case "required_string_float64": - requiredBitSet[18] |= 1 << 0 + requiredBitSet[18] |= 1 << 2 if err := func() error { v, err := json.DecodeStringFloat64(d) s.RequiredStringFloat64 = v @@ -12407,7 +12648,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_float64\"") } case "required_string_hostname": - requiredBitSet[18] |= 1 << 1 + requiredBitSet[18] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringHostname = string(v) @@ -12419,7 +12660,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_hostname\"") } case "required_string_int": - requiredBitSet[18] |= 1 << 2 + requiredBitSet[18] |= 1 << 4 if err := func() error { v, err := json.DecodeStringInt(d) s.RequiredStringInt = v @@ -12431,7 +12672,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int\"") } case "required_string_int16": - requiredBitSet[18] |= 1 << 3 + requiredBitSet[18] |= 1 << 5 if err := func() error { v, err := json.DecodeStringInt16(d) s.RequiredStringInt16 = v @@ -12443,7 +12684,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int16\"") } case "required_string_int32": - requiredBitSet[18] |= 1 << 4 + requiredBitSet[18] |= 1 << 6 if err := func() error { v, err := json.DecodeStringInt32(d) s.RequiredStringInt32 = v @@ -12455,7 +12696,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int32\"") } case "required_string_int64": - requiredBitSet[18] |= 1 << 5 + requiredBitSet[18] |= 1 << 7 if err := func() error { v, err := json.DecodeStringInt64(d) s.RequiredStringInt64 = v @@ -12467,7 +12708,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int64\"") } case "required_string_int8": - requiredBitSet[18] |= 1 << 6 + requiredBitSet[19] |= 1 << 0 if err := func() error { v, err := json.DecodeStringInt8(d) s.RequiredStringInt8 = v @@ -12479,7 +12720,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int8\"") } case "required_string_ip": - requiredBitSet[18] |= 1 << 7 + requiredBitSet[19] |= 1 << 1 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIP = v @@ -12491,7 +12732,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ip\"") } case "required_string_ipv4": - requiredBitSet[19] |= 1 << 0 + requiredBitSet[19] |= 1 << 2 if err := func() error { v, err := json.DecodeIPv4(d) s.RequiredStringIpv4 = v @@ -12503,7 +12744,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv4\"") } case "required_string_ipv6": - requiredBitSet[19] |= 1 << 1 + requiredBitSet[19] |= 1 << 3 if err := func() error { v, err := json.DecodeIPv6(d) s.RequiredStringIpv6 = v @@ -12514,8 +12755,20 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_string_ipv6\"") } + case "required_string_mac": + requiredBitSet[19] |= 1 << 4 + if err := func() error { + v, err := json.DecodeMAC(d) + s.RequiredStringMAC = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_string_mac\"") + } case "required_string_password": - requiredBitSet[19] |= 1 << 2 + requiredBitSet[19] |= 1 << 5 if err := func() error { v, err := d.Str() s.RequiredStringPassword = string(v) @@ -12527,7 +12780,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_password\"") } case "required_string_time": - requiredBitSet[19] |= 1 << 3 + requiredBitSet[19] |= 1 << 6 if err := func() error { v, err := json.DecodeTime(d) s.RequiredStringTime = v @@ -12539,7 +12792,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_time\"") } case "required_string_uint": - requiredBitSet[19] |= 1 << 4 + requiredBitSet[19] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUint(d) s.RequiredStringUint = v @@ -12551,7 +12804,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint\"") } case "required_string_uint16": - requiredBitSet[19] |= 1 << 5 + requiredBitSet[20] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUint16(d) s.RequiredStringUint16 = v @@ -12563,7 +12816,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint16\"") } case "required_string_uint32": - requiredBitSet[19] |= 1 << 6 + requiredBitSet[20] |= 1 << 1 if err := func() error { v, err := json.DecodeStringUint32(d) s.RequiredStringUint32 = v @@ -12575,7 +12828,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint32\"") } case "required_string_uint64": - requiredBitSet[19] |= 1 << 7 + requiredBitSet[20] |= 1 << 2 if err := func() error { v, err := json.DecodeStringUint64(d) s.RequiredStringUint64 = v @@ -12587,7 +12840,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint64\"") } case "required_string_uint8": - requiredBitSet[20] |= 1 << 0 + requiredBitSet[20] |= 1 << 3 if err := func() error { v, err := json.DecodeStringUint8(d) s.RequiredStringUint8 = v @@ -12599,7 +12852,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint8\"") } case "required_string_unix": - requiredBitSet[20] |= 1 << 1 + requiredBitSet[20] |= 1 << 4 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnix = v @@ -12611,7 +12864,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix\"") } case "required_string_unix-micro": - requiredBitSet[20] |= 1 << 2 + requiredBitSet[20] |= 1 << 5 if err := func() error { v, err := json.DecodeStringUnixMicro(d) s.RequiredStringUnixMinusMicro = v @@ -12623,7 +12876,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[20] |= 1 << 3 + requiredBitSet[20] |= 1 << 6 if err := func() error { v, err := json.DecodeStringUnixMilli(d) s.RequiredStringUnixMinusMilli = v @@ -12635,7 +12888,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[20] |= 1 << 4 + requiredBitSet[20] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUnixNano(d) s.RequiredStringUnixMinusNano = v @@ -12647,7 +12900,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[20] |= 1 << 5 + requiredBitSet[21] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnixMinusSeconds = v @@ -12659,7 +12912,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-seconds\"") } case "required_string_uri": - requiredBitSet[20] |= 1 << 6 + requiredBitSet[21] |= 1 << 1 if err := func() error { v, err := json.DecodeURI(d) s.RequiredStringURI = v @@ -12671,7 +12924,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uri\"") } case "required_string_uuid": - requiredBitSet[20] |= 1 << 7 + requiredBitSet[21] |= 1 << 2 if err := func() error { v, err := json.DecodeUUID(d) s.RequiredStringUUID = v @@ -13489,6 +13742,25 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_array_string_ipv6\"") } + case "optional_array_string_mac": + if err := func() error { + s.OptionalArrayStringMAC = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { + return err + } + s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_string_mac\"") + } case "optional_array_string_password": if err := func() error { s.OptionalArrayStringPassword = make([]string, 0) @@ -14897,6 +15169,33 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_double_array_string_ipv6\"") } + case "optional_double_array_string_mac": + if err := func() error { + s.OptionalDoubleArrayStringMAC = make([][]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayStringMAC = append(s.OptionalDoubleArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_string_mac\"") + } case "optional_double_array_string_password": if err := func() error { s.OptionalDoubleArrayStringPassword = make([][]string, 0) @@ -15677,6 +15976,16 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_string_ipv6\"") } + case "optional_string_mac": + if err := func() error { + s.OptionalStringMAC.Reset() + if err := s.OptionalStringMAC.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_string_mac\"") + } case "optional_string_password": if err := func() error { s.OptionalStringPassword.Reset() @@ -15826,7 +16135,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [42]uint8{ + for i, mask := range [43]uint8{ 0b11111111, 0b11111111, 0b11111111, @@ -15848,6 +16157,7 @@ func (s *TestRequestFormatTestReq) Decode(d *jx.Decoder) error { 0b11111111, 0b11111111, 0b11111111, + 0b00000111, 0b00000000, 0b00000000, 0b00000000, @@ -16312,6 +16622,14 @@ func (s *TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + e.FieldStart("required_array_string_mac") + e.ArrStart() + for _, elem := range s.RequiredArrayStringMAC { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } { e.FieldStart("required_array_string_password") e.ArrStart() @@ -16935,6 +17253,18 @@ func (s *TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + e.FieldStart("required_double_array_string_mac") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayStringMAC { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } { e.FieldStart("required_double_array_string_password") e.ArrStart() @@ -17264,6 +17594,10 @@ func (s *TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { e.FieldStart("required_string_ipv6") json.EncodeIPv6(e, s.RequiredStringIpv6) } + { + e.FieldStart("required_string_mac") + json.EncodeMAC(e, s.RequiredStringMAC) + } { e.FieldStart("required_string_password") e.Str(s.RequiredStringPassword) @@ -17749,6 +18083,16 @@ func (s *TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalArrayStringMAC != nil { + e.FieldStart("optional_array_string_mac") + e.ArrStart() + for _, elem := range s.OptionalArrayStringMAC { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + } { if s.OptionalArrayStringPassword != nil { e.FieldStart("optional_array_string_password") @@ -18486,6 +18830,20 @@ func (s *TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalDoubleArrayStringMAC != nil { + e.FieldStart("optional_double_array_string_mac") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayStringMAC { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } { if s.OptionalDoubleArrayStringPassword != nil { e.FieldStart("optional_double_array_string_password") @@ -18918,6 +19276,12 @@ func (s *TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { s.OptionalStringIpv6.Encode(e) } } + { + if s.OptionalStringMAC.Set { + e.FieldStart("optional_string_mac") + s.OptionalStringMAC.Encode(e) + } + } { if s.OptionalStringPassword.Set { e.FieldStart("optional_string_password") @@ -19004,7 +19368,7 @@ func (s *TestRequestRequiredFormatTestReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfTestRequestRequiredFormatTestReq = [336]string{ +var jsonFieldsNameOfTestRequestRequiredFormatTestReq = [342]string{ 0: "required_any", 1: "required_array_any", 2: "required_array_boolean", @@ -19048,299 +19412,305 @@ var jsonFieldsNameOfTestRequestRequiredFormatTestReq = [336]string{ 40: "required_array_string_ip", 41: "required_array_string_ipv4", 42: "required_array_string_ipv6", - 43: "required_array_string_password", - 44: "required_array_string_time", - 45: "required_array_string_uint", - 46: "required_array_string_uint16", - 47: "required_array_string_uint32", - 48: "required_array_string_uint64", - 49: "required_array_string_uint8", - 50: "required_array_string_unix", - 51: "required_array_string_unix-micro", - 52: "required_array_string_unix-milli", - 53: "required_array_string_unix-nano", - 54: "required_array_string_unix-seconds", - 55: "required_array_string_uri", - 56: "required_array_string_uuid", - 57: "required_boolean", - 58: "required_double_array_any", - 59: "required_double_array_boolean", - 60: "required_double_array_integer", - 61: "required_double_array_integer_int16", - 62: "required_double_array_integer_int32", - 63: "required_double_array_integer_int64", - 64: "required_double_array_integer_int8", - 65: "required_double_array_integer_uint", - 66: "required_double_array_integer_uint16", - 67: "required_double_array_integer_uint32", - 68: "required_double_array_integer_uint64", - 69: "required_double_array_integer_uint8", - 70: "required_double_array_integer_unix", - 71: "required_double_array_integer_unix-micro", - 72: "required_double_array_integer_unix-milli", - 73: "required_double_array_integer_unix-nano", - 74: "required_double_array_integer_unix-seconds", - 75: "required_double_array_null", - 76: "required_double_array_number", - 77: "required_double_array_number_double", - 78: "required_double_array_number_float", - 79: "required_double_array_number_int32", - 80: "required_double_array_number_int64", - 81: "required_double_array_string", - 82: "required_double_array_string_base64", - 83: "required_double_array_string_binary", - 84: "required_double_array_string_byte", - 85: "required_double_array_string_date", - 86: "required_double_array_string_date-time", - 87: "required_double_array_string_duration", - 88: "required_double_array_string_email", - 89: "required_double_array_string_float32", - 90: "required_double_array_string_float64", - 91: "required_double_array_string_hostname", - 92: "required_double_array_string_int", - 93: "required_double_array_string_int16", - 94: "required_double_array_string_int32", - 95: "required_double_array_string_int64", - 96: "required_double_array_string_int8", - 97: "required_double_array_string_ip", - 98: "required_double_array_string_ipv4", - 99: "required_double_array_string_ipv6", - 100: "required_double_array_string_password", - 101: "required_double_array_string_time", - 102: "required_double_array_string_uint", - 103: "required_double_array_string_uint16", - 104: "required_double_array_string_uint32", - 105: "required_double_array_string_uint64", - 106: "required_double_array_string_uint8", - 107: "required_double_array_string_unix", - 108: "required_double_array_string_unix-micro", - 109: "required_double_array_string_unix-milli", - 110: "required_double_array_string_unix-nano", - 111: "required_double_array_string_unix-seconds", - 112: "required_double_array_string_uri", - 113: "required_double_array_string_uuid", - 114: "required_integer", - 115: "required_integer_int16", - 116: "required_integer_int32", - 117: "required_integer_int64", - 118: "required_integer_int8", - 119: "required_integer_uint", - 120: "required_integer_uint16", - 121: "required_integer_uint32", - 122: "required_integer_uint64", - 123: "required_integer_uint8", - 124: "required_integer_unix", - 125: "required_integer_unix-micro", - 126: "required_integer_unix-milli", - 127: "required_integer_unix-nano", - 128: "required_integer_unix-seconds", - 129: "required_null", - 130: "required_number", - 131: "required_number_double", - 132: "required_number_float", - 133: "required_number_int32", - 134: "required_number_int64", - 135: "required_string", - 136: "required_string_base64", - 137: "required_string_binary", - 138: "required_string_byte", - 139: "required_string_date", - 140: "required_string_date-time", - 141: "required_string_duration", - 142: "required_string_email", - 143: "required_string_float32", - 144: "required_string_float64", - 145: "required_string_hostname", - 146: "required_string_int", - 147: "required_string_int16", - 148: "required_string_int32", - 149: "required_string_int64", - 150: "required_string_int8", - 151: "required_string_ip", - 152: "required_string_ipv4", - 153: "required_string_ipv6", - 154: "required_string_password", - 155: "required_string_time", - 156: "required_string_uint", - 157: "required_string_uint16", - 158: "required_string_uint32", - 159: "required_string_uint64", - 160: "required_string_uint8", - 161: "required_string_unix", - 162: "required_string_unix-micro", - 163: "required_string_unix-milli", - 164: "required_string_unix-nano", - 165: "required_string_unix-seconds", - 166: "required_string_uri", - 167: "required_string_uuid", - 168: "optional_any", - 169: "optional_array_any", - 170: "optional_array_boolean", - 171: "optional_array_integer", - 172: "optional_array_integer_int16", - 173: "optional_array_integer_int32", - 174: "optional_array_integer_int64", - 175: "optional_array_integer_int8", - 176: "optional_array_integer_uint", - 177: "optional_array_integer_uint16", - 178: "optional_array_integer_uint32", - 179: "optional_array_integer_uint64", - 180: "optional_array_integer_uint8", - 181: "optional_array_integer_unix", - 182: "optional_array_integer_unix-micro", - 183: "optional_array_integer_unix-milli", - 184: "optional_array_integer_unix-nano", - 185: "optional_array_integer_unix-seconds", - 186: "optional_array_null", - 187: "optional_array_number", - 188: "optional_array_number_double", - 189: "optional_array_number_float", - 190: "optional_array_number_int32", - 191: "optional_array_number_int64", - 192: "optional_array_string", - 193: "optional_array_string_base64", - 194: "optional_array_string_binary", - 195: "optional_array_string_byte", - 196: "optional_array_string_date", - 197: "optional_array_string_date-time", - 198: "optional_array_string_duration", - 199: "optional_array_string_email", - 200: "optional_array_string_float32", - 201: "optional_array_string_float64", - 202: "optional_array_string_hostname", - 203: "optional_array_string_int", - 204: "optional_array_string_int16", - 205: "optional_array_string_int32", - 206: "optional_array_string_int64", - 207: "optional_array_string_int8", - 208: "optional_array_string_ip", - 209: "optional_array_string_ipv4", - 210: "optional_array_string_ipv6", - 211: "optional_array_string_password", - 212: "optional_array_string_time", - 213: "optional_array_string_uint", - 214: "optional_array_string_uint16", - 215: "optional_array_string_uint32", - 216: "optional_array_string_uint64", - 217: "optional_array_string_uint8", - 218: "optional_array_string_unix", - 219: "optional_array_string_unix-micro", - 220: "optional_array_string_unix-milli", - 221: "optional_array_string_unix-nano", - 222: "optional_array_string_unix-seconds", - 223: "optional_array_string_uri", - 224: "optional_array_string_uuid", - 225: "optional_boolean", - 226: "optional_double_array_any", - 227: "optional_double_array_boolean", - 228: "optional_double_array_integer", - 229: "optional_double_array_integer_int16", - 230: "optional_double_array_integer_int32", - 231: "optional_double_array_integer_int64", - 232: "optional_double_array_integer_int8", - 233: "optional_double_array_integer_uint", - 234: "optional_double_array_integer_uint16", - 235: "optional_double_array_integer_uint32", - 236: "optional_double_array_integer_uint64", - 237: "optional_double_array_integer_uint8", - 238: "optional_double_array_integer_unix", - 239: "optional_double_array_integer_unix-micro", - 240: "optional_double_array_integer_unix-milli", - 241: "optional_double_array_integer_unix-nano", - 242: "optional_double_array_integer_unix-seconds", - 243: "optional_double_array_null", - 244: "optional_double_array_number", - 245: "optional_double_array_number_double", - 246: "optional_double_array_number_float", - 247: "optional_double_array_number_int32", - 248: "optional_double_array_number_int64", - 249: "optional_double_array_string", - 250: "optional_double_array_string_base64", - 251: "optional_double_array_string_binary", - 252: "optional_double_array_string_byte", - 253: "optional_double_array_string_date", - 254: "optional_double_array_string_date-time", - 255: "optional_double_array_string_duration", - 256: "optional_double_array_string_email", - 257: "optional_double_array_string_float32", - 258: "optional_double_array_string_float64", - 259: "optional_double_array_string_hostname", - 260: "optional_double_array_string_int", - 261: "optional_double_array_string_int16", - 262: "optional_double_array_string_int32", - 263: "optional_double_array_string_int64", - 264: "optional_double_array_string_int8", - 265: "optional_double_array_string_ip", - 266: "optional_double_array_string_ipv4", - 267: "optional_double_array_string_ipv6", - 268: "optional_double_array_string_password", - 269: "optional_double_array_string_time", - 270: "optional_double_array_string_uint", - 271: "optional_double_array_string_uint16", - 272: "optional_double_array_string_uint32", - 273: "optional_double_array_string_uint64", - 274: "optional_double_array_string_uint8", - 275: "optional_double_array_string_unix", - 276: "optional_double_array_string_unix-micro", - 277: "optional_double_array_string_unix-milli", - 278: "optional_double_array_string_unix-nano", - 279: "optional_double_array_string_unix-seconds", - 280: "optional_double_array_string_uri", - 281: "optional_double_array_string_uuid", - 282: "optional_integer", - 283: "optional_integer_int16", - 284: "optional_integer_int32", - 285: "optional_integer_int64", - 286: "optional_integer_int8", - 287: "optional_integer_uint", - 288: "optional_integer_uint16", - 289: "optional_integer_uint32", - 290: "optional_integer_uint64", - 291: "optional_integer_uint8", - 292: "optional_integer_unix", - 293: "optional_integer_unix-micro", - 294: "optional_integer_unix-milli", - 295: "optional_integer_unix-nano", - 296: "optional_integer_unix-seconds", - 297: "optional_null", - 298: "optional_number", - 299: "optional_number_double", - 300: "optional_number_float", - 301: "optional_number_int32", - 302: "optional_number_int64", - 303: "optional_string", - 304: "optional_string_base64", - 305: "optional_string_binary", - 306: "optional_string_byte", - 307: "optional_string_date", - 308: "optional_string_date-time", - 309: "optional_string_duration", - 310: "optional_string_email", - 311: "optional_string_float32", - 312: "optional_string_float64", - 313: "optional_string_hostname", - 314: "optional_string_int", - 315: "optional_string_int16", - 316: "optional_string_int32", - 317: "optional_string_int64", - 318: "optional_string_int8", - 319: "optional_string_ip", - 320: "optional_string_ipv4", - 321: "optional_string_ipv6", - 322: "optional_string_password", - 323: "optional_string_time", - 324: "optional_string_uint", - 325: "optional_string_uint16", - 326: "optional_string_uint32", - 327: "optional_string_uint64", - 328: "optional_string_uint8", - 329: "optional_string_unix", - 330: "optional_string_unix-micro", - 331: "optional_string_unix-milli", - 332: "optional_string_unix-nano", - 333: "optional_string_unix-seconds", - 334: "optional_string_uri", - 335: "optional_string_uuid", + 43: "required_array_string_mac", + 44: "required_array_string_password", + 45: "required_array_string_time", + 46: "required_array_string_uint", + 47: "required_array_string_uint16", + 48: "required_array_string_uint32", + 49: "required_array_string_uint64", + 50: "required_array_string_uint8", + 51: "required_array_string_unix", + 52: "required_array_string_unix-micro", + 53: "required_array_string_unix-milli", + 54: "required_array_string_unix-nano", + 55: "required_array_string_unix-seconds", + 56: "required_array_string_uri", + 57: "required_array_string_uuid", + 58: "required_boolean", + 59: "required_double_array_any", + 60: "required_double_array_boolean", + 61: "required_double_array_integer", + 62: "required_double_array_integer_int16", + 63: "required_double_array_integer_int32", + 64: "required_double_array_integer_int64", + 65: "required_double_array_integer_int8", + 66: "required_double_array_integer_uint", + 67: "required_double_array_integer_uint16", + 68: "required_double_array_integer_uint32", + 69: "required_double_array_integer_uint64", + 70: "required_double_array_integer_uint8", + 71: "required_double_array_integer_unix", + 72: "required_double_array_integer_unix-micro", + 73: "required_double_array_integer_unix-milli", + 74: "required_double_array_integer_unix-nano", + 75: "required_double_array_integer_unix-seconds", + 76: "required_double_array_null", + 77: "required_double_array_number", + 78: "required_double_array_number_double", + 79: "required_double_array_number_float", + 80: "required_double_array_number_int32", + 81: "required_double_array_number_int64", + 82: "required_double_array_string", + 83: "required_double_array_string_base64", + 84: "required_double_array_string_binary", + 85: "required_double_array_string_byte", + 86: "required_double_array_string_date", + 87: "required_double_array_string_date-time", + 88: "required_double_array_string_duration", + 89: "required_double_array_string_email", + 90: "required_double_array_string_float32", + 91: "required_double_array_string_float64", + 92: "required_double_array_string_hostname", + 93: "required_double_array_string_int", + 94: "required_double_array_string_int16", + 95: "required_double_array_string_int32", + 96: "required_double_array_string_int64", + 97: "required_double_array_string_int8", + 98: "required_double_array_string_ip", + 99: "required_double_array_string_ipv4", + 100: "required_double_array_string_ipv6", + 101: "required_double_array_string_mac", + 102: "required_double_array_string_password", + 103: "required_double_array_string_time", + 104: "required_double_array_string_uint", + 105: "required_double_array_string_uint16", + 106: "required_double_array_string_uint32", + 107: "required_double_array_string_uint64", + 108: "required_double_array_string_uint8", + 109: "required_double_array_string_unix", + 110: "required_double_array_string_unix-micro", + 111: "required_double_array_string_unix-milli", + 112: "required_double_array_string_unix-nano", + 113: "required_double_array_string_unix-seconds", + 114: "required_double_array_string_uri", + 115: "required_double_array_string_uuid", + 116: "required_integer", + 117: "required_integer_int16", + 118: "required_integer_int32", + 119: "required_integer_int64", + 120: "required_integer_int8", + 121: "required_integer_uint", + 122: "required_integer_uint16", + 123: "required_integer_uint32", + 124: "required_integer_uint64", + 125: "required_integer_uint8", + 126: "required_integer_unix", + 127: "required_integer_unix-micro", + 128: "required_integer_unix-milli", + 129: "required_integer_unix-nano", + 130: "required_integer_unix-seconds", + 131: "required_null", + 132: "required_number", + 133: "required_number_double", + 134: "required_number_float", + 135: "required_number_int32", + 136: "required_number_int64", + 137: "required_string", + 138: "required_string_base64", + 139: "required_string_binary", + 140: "required_string_byte", + 141: "required_string_date", + 142: "required_string_date-time", + 143: "required_string_duration", + 144: "required_string_email", + 145: "required_string_float32", + 146: "required_string_float64", + 147: "required_string_hostname", + 148: "required_string_int", + 149: "required_string_int16", + 150: "required_string_int32", + 151: "required_string_int64", + 152: "required_string_int8", + 153: "required_string_ip", + 154: "required_string_ipv4", + 155: "required_string_ipv6", + 156: "required_string_mac", + 157: "required_string_password", + 158: "required_string_time", + 159: "required_string_uint", + 160: "required_string_uint16", + 161: "required_string_uint32", + 162: "required_string_uint64", + 163: "required_string_uint8", + 164: "required_string_unix", + 165: "required_string_unix-micro", + 166: "required_string_unix-milli", + 167: "required_string_unix-nano", + 168: "required_string_unix-seconds", + 169: "required_string_uri", + 170: "required_string_uuid", + 171: "optional_any", + 172: "optional_array_any", + 173: "optional_array_boolean", + 174: "optional_array_integer", + 175: "optional_array_integer_int16", + 176: "optional_array_integer_int32", + 177: "optional_array_integer_int64", + 178: "optional_array_integer_int8", + 179: "optional_array_integer_uint", + 180: "optional_array_integer_uint16", + 181: "optional_array_integer_uint32", + 182: "optional_array_integer_uint64", + 183: "optional_array_integer_uint8", + 184: "optional_array_integer_unix", + 185: "optional_array_integer_unix-micro", + 186: "optional_array_integer_unix-milli", + 187: "optional_array_integer_unix-nano", + 188: "optional_array_integer_unix-seconds", + 189: "optional_array_null", + 190: "optional_array_number", + 191: "optional_array_number_double", + 192: "optional_array_number_float", + 193: "optional_array_number_int32", + 194: "optional_array_number_int64", + 195: "optional_array_string", + 196: "optional_array_string_base64", + 197: "optional_array_string_binary", + 198: "optional_array_string_byte", + 199: "optional_array_string_date", + 200: "optional_array_string_date-time", + 201: "optional_array_string_duration", + 202: "optional_array_string_email", + 203: "optional_array_string_float32", + 204: "optional_array_string_float64", + 205: "optional_array_string_hostname", + 206: "optional_array_string_int", + 207: "optional_array_string_int16", + 208: "optional_array_string_int32", + 209: "optional_array_string_int64", + 210: "optional_array_string_int8", + 211: "optional_array_string_ip", + 212: "optional_array_string_ipv4", + 213: "optional_array_string_ipv6", + 214: "optional_array_string_mac", + 215: "optional_array_string_password", + 216: "optional_array_string_time", + 217: "optional_array_string_uint", + 218: "optional_array_string_uint16", + 219: "optional_array_string_uint32", + 220: "optional_array_string_uint64", + 221: "optional_array_string_uint8", + 222: "optional_array_string_unix", + 223: "optional_array_string_unix-micro", + 224: "optional_array_string_unix-milli", + 225: "optional_array_string_unix-nano", + 226: "optional_array_string_unix-seconds", + 227: "optional_array_string_uri", + 228: "optional_array_string_uuid", + 229: "optional_boolean", + 230: "optional_double_array_any", + 231: "optional_double_array_boolean", + 232: "optional_double_array_integer", + 233: "optional_double_array_integer_int16", + 234: "optional_double_array_integer_int32", + 235: "optional_double_array_integer_int64", + 236: "optional_double_array_integer_int8", + 237: "optional_double_array_integer_uint", + 238: "optional_double_array_integer_uint16", + 239: "optional_double_array_integer_uint32", + 240: "optional_double_array_integer_uint64", + 241: "optional_double_array_integer_uint8", + 242: "optional_double_array_integer_unix", + 243: "optional_double_array_integer_unix-micro", + 244: "optional_double_array_integer_unix-milli", + 245: "optional_double_array_integer_unix-nano", + 246: "optional_double_array_integer_unix-seconds", + 247: "optional_double_array_null", + 248: "optional_double_array_number", + 249: "optional_double_array_number_double", + 250: "optional_double_array_number_float", + 251: "optional_double_array_number_int32", + 252: "optional_double_array_number_int64", + 253: "optional_double_array_string", + 254: "optional_double_array_string_base64", + 255: "optional_double_array_string_binary", + 256: "optional_double_array_string_byte", + 257: "optional_double_array_string_date", + 258: "optional_double_array_string_date-time", + 259: "optional_double_array_string_duration", + 260: "optional_double_array_string_email", + 261: "optional_double_array_string_float32", + 262: "optional_double_array_string_float64", + 263: "optional_double_array_string_hostname", + 264: "optional_double_array_string_int", + 265: "optional_double_array_string_int16", + 266: "optional_double_array_string_int32", + 267: "optional_double_array_string_int64", + 268: "optional_double_array_string_int8", + 269: "optional_double_array_string_ip", + 270: "optional_double_array_string_ipv4", + 271: "optional_double_array_string_ipv6", + 272: "optional_double_array_string_mac", + 273: "optional_double_array_string_password", + 274: "optional_double_array_string_time", + 275: "optional_double_array_string_uint", + 276: "optional_double_array_string_uint16", + 277: "optional_double_array_string_uint32", + 278: "optional_double_array_string_uint64", + 279: "optional_double_array_string_uint8", + 280: "optional_double_array_string_unix", + 281: "optional_double_array_string_unix-micro", + 282: "optional_double_array_string_unix-milli", + 283: "optional_double_array_string_unix-nano", + 284: "optional_double_array_string_unix-seconds", + 285: "optional_double_array_string_uri", + 286: "optional_double_array_string_uuid", + 287: "optional_integer", + 288: "optional_integer_int16", + 289: "optional_integer_int32", + 290: "optional_integer_int64", + 291: "optional_integer_int8", + 292: "optional_integer_uint", + 293: "optional_integer_uint16", + 294: "optional_integer_uint32", + 295: "optional_integer_uint64", + 296: "optional_integer_uint8", + 297: "optional_integer_unix", + 298: "optional_integer_unix-micro", + 299: "optional_integer_unix-milli", + 300: "optional_integer_unix-nano", + 301: "optional_integer_unix-seconds", + 302: "optional_null", + 303: "optional_number", + 304: "optional_number_double", + 305: "optional_number_float", + 306: "optional_number_int32", + 307: "optional_number_int64", + 308: "optional_string", + 309: "optional_string_base64", + 310: "optional_string_binary", + 311: "optional_string_byte", + 312: "optional_string_date", + 313: "optional_string_date-time", + 314: "optional_string_duration", + 315: "optional_string_email", + 316: "optional_string_float32", + 317: "optional_string_float64", + 318: "optional_string_hostname", + 319: "optional_string_int", + 320: "optional_string_int16", + 321: "optional_string_int32", + 322: "optional_string_int64", + 323: "optional_string_int8", + 324: "optional_string_ip", + 325: "optional_string_ipv4", + 326: "optional_string_ipv6", + 327: "optional_string_mac", + 328: "optional_string_password", + 329: "optional_string_time", + 330: "optional_string_uint", + 331: "optional_string_uint16", + 332: "optional_string_uint32", + 333: "optional_string_uint64", + 334: "optional_string_uint8", + 335: "optional_string_unix", + 336: "optional_string_unix-micro", + 337: "optional_string_unix-milli", + 338: "optional_string_unix-nano", + 339: "optional_string_unix-seconds", + 340: "optional_string_uri", + 341: "optional_string_uuid", } // Decode decodes TestRequestRequiredFormatTestReq from json. @@ -19348,7 +19718,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode TestRequestRequiredFormatTestReq to nil") } - var requiredBitSet [42]uint8 + var requiredBitSet [43]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -20202,8 +20572,28 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_array_string_ipv6\"") } - case "required_array_string_password": + case "required_array_string_mac": requiredBitSet[5] |= 1 << 3 + if err := func() error { + s.RequiredArrayStringMAC = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { + return err + } + s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_string_mac\"") + } + case "required_array_string_password": + requiredBitSet[5] |= 1 << 4 if err := func() error { s.RequiredArrayStringPassword = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20223,7 +20613,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[5] |= 1 << 4 + requiredBitSet[5] |= 1 << 5 if err := func() error { s.RequiredArrayStringTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20243,7 +20633,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_time\"") } case "required_array_string_uint": - requiredBitSet[5] |= 1 << 5 + requiredBitSet[5] |= 1 << 6 if err := func() error { s.RequiredArrayStringUint = make([]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20263,7 +20653,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint\"") } case "required_array_string_uint16": - requiredBitSet[5] |= 1 << 6 + requiredBitSet[5] |= 1 << 7 if err := func() error { s.RequiredArrayStringUint16 = make([]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20283,7 +20673,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint16\"") } case "required_array_string_uint32": - requiredBitSet[5] |= 1 << 7 + requiredBitSet[6] |= 1 << 0 if err := func() error { s.RequiredArrayStringUint32 = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20303,7 +20693,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint32\"") } case "required_array_string_uint64": - requiredBitSet[6] |= 1 << 0 + requiredBitSet[6] |= 1 << 1 if err := func() error { s.RequiredArrayStringUint64 = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20323,7 +20713,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint64\"") } case "required_array_string_uint8": - requiredBitSet[6] |= 1 << 1 + requiredBitSet[6] |= 1 << 2 if err := func() error { s.RequiredArrayStringUint8 = make([]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20343,7 +20733,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint8\"") } case "required_array_string_unix": - requiredBitSet[6] |= 1 << 2 + requiredBitSet[6] |= 1 << 3 if err := func() error { s.RequiredArrayStringUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20363,7 +20753,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[6] |= 1 << 3 + requiredBitSet[6] |= 1 << 4 if err := func() error { s.RequiredArrayStringUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20383,7 +20773,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[6] |= 1 << 4 + requiredBitSet[6] |= 1 << 5 if err := func() error { s.RequiredArrayStringUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20403,7 +20793,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[6] |= 1 << 5 + requiredBitSet[6] |= 1 << 6 if err := func() error { s.RequiredArrayStringUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20423,7 +20813,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[6] |= 1 << 6 + requiredBitSet[6] |= 1 << 7 if err := func() error { s.RequiredArrayStringUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20443,7 +20833,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[6] |= 1 << 7 + requiredBitSet[7] |= 1 << 0 if err := func() error { s.RequiredArrayStringURI = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20463,7 +20853,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[7] |= 1 << 0 + requiredBitSet[7] |= 1 << 1 if err := func() error { s.RequiredArrayStringUUID = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20483,7 +20873,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uuid\"") } case "required_boolean": - requiredBitSet[7] |= 1 << 1 + requiredBitSet[7] |= 1 << 2 if err := func() error { v, err := d.Bool() s.RequiredBoolean = bool(v) @@ -20495,7 +20885,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_boolean\"") } case "required_double_array_any": - requiredBitSet[7] |= 1 << 2 + requiredBitSet[7] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayAny = make([][]jx.Raw, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20523,7 +20913,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[7] |= 1 << 3 + requiredBitSet[7] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayBoolean = make([][]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20551,7 +20941,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[7] |= 1 << 4 + requiredBitSet[7] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayInteger = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20579,7 +20969,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer\"") } case "required_double_array_integer_int16": - requiredBitSet[7] |= 1 << 5 + requiredBitSet[7] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerInt16 = make([][]int16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20607,7 +20997,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int16\"") } case "required_double_array_integer_int32": - requiredBitSet[7] |= 1 << 6 + requiredBitSet[7] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20635,7 +21025,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[7] |= 1 << 7 + requiredBitSet[8] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayIntegerInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20663,7 +21053,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int64\"") } case "required_double_array_integer_int8": - requiredBitSet[8] |= 1 << 0 + requiredBitSet[8] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayIntegerInt8 = make([][]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20691,7 +21081,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int8\"") } case "required_double_array_integer_uint": - requiredBitSet[8] |= 1 << 1 + requiredBitSet[8] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayIntegerUint = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20719,7 +21109,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint\"") } case "required_double_array_integer_uint16": - requiredBitSet[8] |= 1 << 2 + requiredBitSet[8] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUint16 = make([][]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20747,7 +21137,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint16\"") } case "required_double_array_integer_uint32": - requiredBitSet[8] |= 1 << 3 + requiredBitSet[8] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayIntegerUint32 = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20775,7 +21165,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint32\"") } case "required_double_array_integer_uint64": - requiredBitSet[8] |= 1 << 4 + requiredBitSet[8] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayIntegerUint64 = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20803,7 +21193,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint64\"") } case "required_double_array_integer_uint8": - requiredBitSet[8] |= 1 << 5 + requiredBitSet[8] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerUint8 = make([][]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20831,7 +21221,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint8\"") } case "required_double_array_integer_unix": - requiredBitSet[8] |= 1 << 6 + requiredBitSet[8] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20859,7 +21249,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[8] |= 1 << 7 + requiredBitSet[9] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20887,7 +21277,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[9] |= 1 << 0 + requiredBitSet[9] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20915,7 +21305,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[9] |= 1 << 1 + requiredBitSet[9] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20943,7 +21333,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[9] |= 1 << 2 + requiredBitSet[9] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20971,7 +21361,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[9] |= 1 << 3 + requiredBitSet[9] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayNull = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -20997,7 +21387,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[9] |= 1 << 4 + requiredBitSet[9] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayNumber = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21025,7 +21415,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[9] |= 1 << 5 + requiredBitSet[9] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayNumberDouble = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21053,7 +21443,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[9] |= 1 << 6 + requiredBitSet[9] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayNumberFloat = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21081,7 +21471,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[9] |= 1 << 7 + requiredBitSet[10] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayNumberInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21109,7 +21499,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[10] |= 1 << 0 + requiredBitSet[10] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayNumberInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21137,7 +21527,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[10] |= 1 << 1 + requiredBitSet[10] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayString = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21165,7 +21555,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string\"") } case "required_double_array_string_base64": - requiredBitSet[10] |= 1 << 2 + requiredBitSet[10] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringBase64 = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21193,7 +21583,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_base64\"") } case "required_double_array_string_binary": - requiredBitSet[10] |= 1 << 3 + requiredBitSet[10] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringBinary = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21221,7 +21611,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[10] |= 1 << 4 + requiredBitSet[10] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringByte = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21249,7 +21639,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[10] |= 1 << 5 + requiredBitSet[10] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringDate = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21277,7 +21667,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[10] |= 1 << 6 + requiredBitSet[10] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringDateMinusTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21305,7 +21695,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[10] |= 1 << 7 + requiredBitSet[11] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringDuration = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21333,7 +21723,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[11] |= 1 << 0 + requiredBitSet[11] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringEmail = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21361,7 +21751,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_float32": - requiredBitSet[11] |= 1 << 1 + requiredBitSet[11] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringFloat32 = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21389,7 +21779,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_float32\"") } case "required_double_array_string_float64": - requiredBitSet[11] |= 1 << 2 + requiredBitSet[11] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringFloat64 = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21417,7 +21807,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_float64\"") } case "required_double_array_string_hostname": - requiredBitSet[11] |= 1 << 3 + requiredBitSet[11] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringHostname = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21445,7 +21835,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_int": - requiredBitSet[11] |= 1 << 4 + requiredBitSet[11] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringInt = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21473,7 +21863,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int\"") } case "required_double_array_string_int16": - requiredBitSet[11] |= 1 << 5 + requiredBitSet[11] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringInt16 = make([][]int16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21501,7 +21891,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int16\"") } case "required_double_array_string_int32": - requiredBitSet[11] |= 1 << 6 + requiredBitSet[11] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21529,7 +21919,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[11] |= 1 << 7 + requiredBitSet[12] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21557,7 +21947,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_int8": - requiredBitSet[12] |= 1 << 0 + requiredBitSet[12] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringInt8 = make([][]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21585,7 +21975,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int8\"") } case "required_double_array_string_ip": - requiredBitSet[12] |= 1 << 1 + requiredBitSet[12] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringIP = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21613,7 +22003,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[12] |= 1 << 2 + requiredBitSet[12] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringIpv4 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21641,7 +22031,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[12] |= 1 << 3 + requiredBitSet[12] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringIpv6 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21668,8 +22058,36 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_double_array_string_ipv6\"") } + case "required_double_array_string_mac": + requiredBitSet[12] |= 1 << 5 + if err := func() error { + s.RequiredDoubleArrayStringMAC = make([][]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayStringMAC = append(s.RequiredDoubleArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_string_mac\"") + } case "required_double_array_string_password": - requiredBitSet[12] |= 1 << 4 + requiredBitSet[12] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringPassword = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21697,7 +22115,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[12] |= 1 << 5 + requiredBitSet[12] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21725,7 +22143,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_uint": - requiredBitSet[12] |= 1 << 6 + requiredBitSet[13] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUint = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21753,7 +22171,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint\"") } case "required_double_array_string_uint16": - requiredBitSet[12] |= 1 << 7 + requiredBitSet[13] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUint16 = make([][]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21781,7 +22199,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint16\"") } case "required_double_array_string_uint32": - requiredBitSet[13] |= 1 << 0 + requiredBitSet[13] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringUint32 = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21809,7 +22227,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint32\"") } case "required_double_array_string_uint64": - requiredBitSet[13] |= 1 << 1 + requiredBitSet[13] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUint64 = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21837,7 +22255,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint64\"") } case "required_double_array_string_uint8": - requiredBitSet[13] |= 1 << 2 + requiredBitSet[13] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringUint8 = make([][]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21865,7 +22283,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint8\"") } case "required_double_array_string_unix": - requiredBitSet[13] |= 1 << 3 + requiredBitSet[13] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21893,7 +22311,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[13] |= 1 << 4 + requiredBitSet[13] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21921,7 +22339,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[13] |= 1 << 5 + requiredBitSet[13] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21949,7 +22367,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[13] |= 1 << 6 + requiredBitSet[14] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -21977,7 +22395,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[13] |= 1 << 7 + requiredBitSet[14] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -22005,7 +22423,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[14] |= 1 << 0 + requiredBitSet[14] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringURI = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -22033,7 +22451,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[14] |= 1 << 1 + requiredBitSet[14] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUUID = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -22061,7 +22479,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uuid\"") } case "required_integer": - requiredBitSet[14] |= 1 << 2 + requiredBitSet[14] |= 1 << 4 if err := func() error { v, err := d.Int() s.RequiredInteger = int(v) @@ -22073,7 +22491,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer\"") } case "required_integer_int16": - requiredBitSet[14] |= 1 << 3 + requiredBitSet[14] |= 1 << 5 if err := func() error { v, err := d.Int16() s.RequiredIntegerInt16 = int16(v) @@ -22085,7 +22503,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int16\"") } case "required_integer_int32": - requiredBitSet[14] |= 1 << 4 + requiredBitSet[14] |= 1 << 6 if err := func() error { v, err := d.Int32() s.RequiredIntegerInt32 = int32(v) @@ -22097,7 +22515,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int32\"") } case "required_integer_int64": - requiredBitSet[14] |= 1 << 5 + requiredBitSet[14] |= 1 << 7 if err := func() error { v, err := d.Int64() s.RequiredIntegerInt64 = int64(v) @@ -22109,7 +22527,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int64\"") } case "required_integer_int8": - requiredBitSet[14] |= 1 << 6 + requiredBitSet[15] |= 1 << 0 if err := func() error { v, err := d.Int8() s.RequiredIntegerInt8 = int8(v) @@ -22121,7 +22539,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int8\"") } case "required_integer_uint": - requiredBitSet[14] |= 1 << 7 + requiredBitSet[15] |= 1 << 1 if err := func() error { v, err := d.UInt() s.RequiredIntegerUint = uint(v) @@ -22133,7 +22551,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint\"") } case "required_integer_uint16": - requiredBitSet[15] |= 1 << 0 + requiredBitSet[15] |= 1 << 2 if err := func() error { v, err := d.UInt16() s.RequiredIntegerUint16 = uint16(v) @@ -22145,7 +22563,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint16\"") } case "required_integer_uint32": - requiredBitSet[15] |= 1 << 1 + requiredBitSet[15] |= 1 << 3 if err := func() error { v, err := d.UInt32() s.RequiredIntegerUint32 = uint32(v) @@ -22157,7 +22575,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint32\"") } case "required_integer_uint64": - requiredBitSet[15] |= 1 << 2 + requiredBitSet[15] |= 1 << 4 if err := func() error { v, err := d.UInt64() s.RequiredIntegerUint64 = uint64(v) @@ -22169,7 +22587,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint64\"") } case "required_integer_uint8": - requiredBitSet[15] |= 1 << 3 + requiredBitSet[15] |= 1 << 5 if err := func() error { v, err := d.UInt8() s.RequiredIntegerUint8 = uint8(v) @@ -22181,7 +22599,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint8\"") } case "required_integer_unix": - requiredBitSet[15] |= 1 << 4 + requiredBitSet[15] |= 1 << 6 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnix = v @@ -22193,7 +22611,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix\"") } case "required_integer_unix-micro": - requiredBitSet[15] |= 1 << 5 + requiredBitSet[15] |= 1 << 7 if err := func() error { v, err := json.DecodeUnixMicro(d) s.RequiredIntegerUnixMinusMicro = v @@ -22205,7 +22623,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[15] |= 1 << 6 + requiredBitSet[16] |= 1 << 0 if err := func() error { v, err := json.DecodeUnixMilli(d) s.RequiredIntegerUnixMinusMilli = v @@ -22217,7 +22635,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[15] |= 1 << 7 + requiredBitSet[16] |= 1 << 1 if err := func() error { v, err := json.DecodeUnixNano(d) s.RequiredIntegerUnixMinusNano = v @@ -22229,7 +22647,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[16] |= 1 << 0 + requiredBitSet[16] |= 1 << 2 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnixMinusSeconds = v @@ -22241,7 +22659,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-seconds\"") } case "required_null": - requiredBitSet[16] |= 1 << 1 + requiredBitSet[16] |= 1 << 3 if err := func() error { if err := d.Null(); err != nil { return err @@ -22251,7 +22669,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_null\"") } case "required_number": - requiredBitSet[16] |= 1 << 2 + requiredBitSet[16] |= 1 << 4 if err := func() error { v, err := d.Float64() s.RequiredNumber = float64(v) @@ -22263,7 +22681,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number\"") } case "required_number_double": - requiredBitSet[16] |= 1 << 3 + requiredBitSet[16] |= 1 << 5 if err := func() error { v, err := d.Float64() s.RequiredNumberDouble = float64(v) @@ -22275,7 +22693,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_double\"") } case "required_number_float": - requiredBitSet[16] |= 1 << 4 + requiredBitSet[16] |= 1 << 6 if err := func() error { v, err := d.Float32() s.RequiredNumberFloat = float32(v) @@ -22287,7 +22705,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_float\"") } case "required_number_int32": - requiredBitSet[16] |= 1 << 5 + requiredBitSet[16] |= 1 << 7 if err := func() error { v, err := d.Int32() s.RequiredNumberInt32 = int32(v) @@ -22299,7 +22717,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int32\"") } case "required_number_int64": - requiredBitSet[16] |= 1 << 6 + requiredBitSet[17] |= 1 << 0 if err := func() error { v, err := d.Int64() s.RequiredNumberInt64 = int64(v) @@ -22311,7 +22729,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int64\"") } case "required_string": - requiredBitSet[16] |= 1 << 7 + requiredBitSet[17] |= 1 << 1 if err := func() error { v, err := d.Str() s.RequiredString = string(v) @@ -22323,7 +22741,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string\"") } case "required_string_base64": - requiredBitSet[17] |= 1 << 0 + requiredBitSet[17] |= 1 << 2 if err := func() error { v, err := d.Base64() s.RequiredStringBase64 = []byte(v) @@ -22335,7 +22753,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_base64\"") } case "required_string_binary": - requiredBitSet[17] |= 1 << 1 + requiredBitSet[17] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringBinary = string(v) @@ -22347,7 +22765,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_binary\"") } case "required_string_byte": - requiredBitSet[17] |= 1 << 2 + requiredBitSet[17] |= 1 << 4 if err := func() error { v, err := d.Base64() s.RequiredStringByte = []byte(v) @@ -22359,7 +22777,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_byte\"") } case "required_string_date": - requiredBitSet[17] |= 1 << 3 + requiredBitSet[17] |= 1 << 5 if err := func() error { v, err := json.DecodeDate(d) s.RequiredStringDate = v @@ -22371,7 +22789,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date\"") } case "required_string_date-time": - requiredBitSet[17] |= 1 << 4 + requiredBitSet[17] |= 1 << 6 if err := func() error { v, err := json.DecodeDateTime(d) s.RequiredStringDateMinusTime = v @@ -22383,7 +22801,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date-time\"") } case "required_string_duration": - requiredBitSet[17] |= 1 << 5 + requiredBitSet[17] |= 1 << 7 if err := func() error { v, err := json.DecodeDuration(d) s.RequiredStringDuration = v @@ -22395,7 +22813,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_duration\"") } case "required_string_email": - requiredBitSet[17] |= 1 << 6 + requiredBitSet[18] |= 1 << 0 if err := func() error { v, err := d.Str() s.RequiredStringEmail = string(v) @@ -22407,7 +22825,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_email\"") } case "required_string_float32": - requiredBitSet[17] |= 1 << 7 + requiredBitSet[18] |= 1 << 1 if err := func() error { v, err := json.DecodeStringFloat32(d) s.RequiredStringFloat32 = v @@ -22419,7 +22837,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_float32\"") } case "required_string_float64": - requiredBitSet[18] |= 1 << 0 + requiredBitSet[18] |= 1 << 2 if err := func() error { v, err := json.DecodeStringFloat64(d) s.RequiredStringFloat64 = v @@ -22431,7 +22849,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_float64\"") } case "required_string_hostname": - requiredBitSet[18] |= 1 << 1 + requiredBitSet[18] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringHostname = string(v) @@ -22443,7 +22861,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_hostname\"") } case "required_string_int": - requiredBitSet[18] |= 1 << 2 + requiredBitSet[18] |= 1 << 4 if err := func() error { v, err := json.DecodeStringInt(d) s.RequiredStringInt = v @@ -22455,7 +22873,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int\"") } case "required_string_int16": - requiredBitSet[18] |= 1 << 3 + requiredBitSet[18] |= 1 << 5 if err := func() error { v, err := json.DecodeStringInt16(d) s.RequiredStringInt16 = v @@ -22467,7 +22885,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int16\"") } case "required_string_int32": - requiredBitSet[18] |= 1 << 4 + requiredBitSet[18] |= 1 << 6 if err := func() error { v, err := json.DecodeStringInt32(d) s.RequiredStringInt32 = v @@ -22479,7 +22897,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int32\"") } case "required_string_int64": - requiredBitSet[18] |= 1 << 5 + requiredBitSet[18] |= 1 << 7 if err := func() error { v, err := json.DecodeStringInt64(d) s.RequiredStringInt64 = v @@ -22491,7 +22909,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int64\"") } case "required_string_int8": - requiredBitSet[18] |= 1 << 6 + requiredBitSet[19] |= 1 << 0 if err := func() error { v, err := json.DecodeStringInt8(d) s.RequiredStringInt8 = v @@ -22503,7 +22921,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int8\"") } case "required_string_ip": - requiredBitSet[18] |= 1 << 7 + requiredBitSet[19] |= 1 << 1 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIP = v @@ -22515,7 +22933,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ip\"") } case "required_string_ipv4": - requiredBitSet[19] |= 1 << 0 + requiredBitSet[19] |= 1 << 2 if err := func() error { v, err := json.DecodeIPv4(d) s.RequiredStringIpv4 = v @@ -22527,7 +22945,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv4\"") } case "required_string_ipv6": - requiredBitSet[19] |= 1 << 1 + requiredBitSet[19] |= 1 << 3 if err := func() error { v, err := json.DecodeIPv6(d) s.RequiredStringIpv6 = v @@ -22538,8 +22956,20 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_string_ipv6\"") } + case "required_string_mac": + requiredBitSet[19] |= 1 << 4 + if err := func() error { + v, err := json.DecodeMAC(d) + s.RequiredStringMAC = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_string_mac\"") + } case "required_string_password": - requiredBitSet[19] |= 1 << 2 + requiredBitSet[19] |= 1 << 5 if err := func() error { v, err := d.Str() s.RequiredStringPassword = string(v) @@ -22551,7 +22981,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_password\"") } case "required_string_time": - requiredBitSet[19] |= 1 << 3 + requiredBitSet[19] |= 1 << 6 if err := func() error { v, err := json.DecodeTime(d) s.RequiredStringTime = v @@ -22563,7 +22993,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_time\"") } case "required_string_uint": - requiredBitSet[19] |= 1 << 4 + requiredBitSet[19] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUint(d) s.RequiredStringUint = v @@ -22575,7 +23005,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint\"") } case "required_string_uint16": - requiredBitSet[19] |= 1 << 5 + requiredBitSet[20] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUint16(d) s.RequiredStringUint16 = v @@ -22587,7 +23017,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint16\"") } case "required_string_uint32": - requiredBitSet[19] |= 1 << 6 + requiredBitSet[20] |= 1 << 1 if err := func() error { v, err := json.DecodeStringUint32(d) s.RequiredStringUint32 = v @@ -22599,7 +23029,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint32\"") } case "required_string_uint64": - requiredBitSet[19] |= 1 << 7 + requiredBitSet[20] |= 1 << 2 if err := func() error { v, err := json.DecodeStringUint64(d) s.RequiredStringUint64 = v @@ -22611,7 +23041,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint64\"") } case "required_string_uint8": - requiredBitSet[20] |= 1 << 0 + requiredBitSet[20] |= 1 << 3 if err := func() error { v, err := json.DecodeStringUint8(d) s.RequiredStringUint8 = v @@ -22623,7 +23053,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint8\"") } case "required_string_unix": - requiredBitSet[20] |= 1 << 1 + requiredBitSet[20] |= 1 << 4 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnix = v @@ -22635,7 +23065,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix\"") } case "required_string_unix-micro": - requiredBitSet[20] |= 1 << 2 + requiredBitSet[20] |= 1 << 5 if err := func() error { v, err := json.DecodeStringUnixMicro(d) s.RequiredStringUnixMinusMicro = v @@ -22647,7 +23077,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[20] |= 1 << 3 + requiredBitSet[20] |= 1 << 6 if err := func() error { v, err := json.DecodeStringUnixMilli(d) s.RequiredStringUnixMinusMilli = v @@ -22659,7 +23089,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[20] |= 1 << 4 + requiredBitSet[20] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUnixNano(d) s.RequiredStringUnixMinusNano = v @@ -22671,7 +23101,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[20] |= 1 << 5 + requiredBitSet[21] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnixMinusSeconds = v @@ -22683,7 +23113,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-seconds\"") } case "required_string_uri": - requiredBitSet[20] |= 1 << 6 + requiredBitSet[21] |= 1 << 1 if err := func() error { v, err := json.DecodeURI(d) s.RequiredStringURI = v @@ -22695,7 +23125,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uri\"") } case "required_string_uuid": - requiredBitSet[20] |= 1 << 7 + requiredBitSet[21] |= 1 << 2 if err := func() error { v, err := json.DecodeUUID(d) s.RequiredStringUUID = v @@ -23513,6 +23943,25 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_array_string_ipv6\"") } + case "optional_array_string_mac": + if err := func() error { + s.OptionalArrayStringMAC = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { + return err + } + s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_string_mac\"") + } case "optional_array_string_password": if err := func() error { s.OptionalArrayStringPassword = make([]string, 0) @@ -24921,6 +25370,33 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_double_array_string_ipv6\"") } + case "optional_double_array_string_mac": + if err := func() error { + s.OptionalDoubleArrayStringMAC = make([][]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayStringMAC = append(s.OptionalDoubleArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_string_mac\"") + } case "optional_double_array_string_password": if err := func() error { s.OptionalDoubleArrayStringPassword = make([][]string, 0) @@ -25701,6 +26177,16 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_string_ipv6\"") } + case "optional_string_mac": + if err := func() error { + s.OptionalStringMAC.Reset() + if err := s.OptionalStringMAC.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_string_mac\"") + } case "optional_string_password": if err := func() error { s.OptionalStringPassword.Reset() @@ -25850,7 +26336,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [42]uint8{ + for i, mask := range [43]uint8{ 0b11111111, 0b11111111, 0b11111111, @@ -25872,6 +26358,7 @@ func (s *TestRequestRequiredFormatTestReq) Decode(d *jx.Decoder) error { 0b11111111, 0b11111111, 0b11111111, + 0b00000111, 0b00000000, 0b00000000, 0b00000000, @@ -26336,6 +26823,14 @@ func (s *TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + e.FieldStart("required_array_string_mac") + e.ArrStart() + for _, elem := range s.RequiredArrayStringMAC { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } { e.FieldStart("required_array_string_password") e.ArrStart() @@ -26959,6 +27454,18 @@ func (s *TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } e.ArrEnd() } + { + e.FieldStart("required_double_array_string_mac") + e.ArrStart() + for _, elem := range s.RequiredDoubleArrayStringMAC { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } { e.FieldStart("required_double_array_string_password") e.ArrStart() @@ -27288,6 +27795,10 @@ func (s *TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { e.FieldStart("required_string_ipv6") json.EncodeIPv6(e, s.RequiredStringIpv6) } + { + e.FieldStart("required_string_mac") + json.EncodeMAC(e, s.RequiredStringMAC) + } { e.FieldStart("required_string_password") e.Str(s.RequiredStringPassword) @@ -27773,6 +28284,16 @@ func (s *TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalArrayStringMAC != nil { + e.FieldStart("optional_array_string_mac") + e.ArrStart() + for _, elem := range s.OptionalArrayStringMAC { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + } { if s.OptionalArrayStringPassword != nil { e.FieldStart("optional_array_string_password") @@ -28510,6 +29031,20 @@ func (s *TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.OptionalDoubleArrayStringMAC != nil { + e.FieldStart("optional_double_array_string_mac") + e.ArrStart() + for _, elem := range s.OptionalDoubleArrayStringMAC { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } { if s.OptionalDoubleArrayStringPassword != nil { e.FieldStart("optional_double_array_string_password") @@ -28942,6 +29477,12 @@ func (s *TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { s.OptionalStringIpv6.Encode(e) } } + { + if s.OptionalStringMAC.Set { + e.FieldStart("optional_string_mac") + s.OptionalStringMAC.Encode(e) + } + } { if s.OptionalStringPassword.Set { e.FieldStart("optional_string_password") @@ -29028,7 +29569,7 @@ func (s *TestResponseFormatTestOK) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfTestResponseFormatTestOK = [336]string{ +var jsonFieldsNameOfTestResponseFormatTestOK = [342]string{ 0: "required_any", 1: "required_array_any", 2: "required_array_boolean", @@ -29072,299 +29613,305 @@ var jsonFieldsNameOfTestResponseFormatTestOK = [336]string{ 40: "required_array_string_ip", 41: "required_array_string_ipv4", 42: "required_array_string_ipv6", - 43: "required_array_string_password", - 44: "required_array_string_time", - 45: "required_array_string_uint", - 46: "required_array_string_uint16", - 47: "required_array_string_uint32", - 48: "required_array_string_uint64", - 49: "required_array_string_uint8", - 50: "required_array_string_unix", - 51: "required_array_string_unix-micro", - 52: "required_array_string_unix-milli", - 53: "required_array_string_unix-nano", - 54: "required_array_string_unix-seconds", - 55: "required_array_string_uri", - 56: "required_array_string_uuid", - 57: "required_boolean", - 58: "required_double_array_any", - 59: "required_double_array_boolean", - 60: "required_double_array_integer", - 61: "required_double_array_integer_int16", - 62: "required_double_array_integer_int32", - 63: "required_double_array_integer_int64", - 64: "required_double_array_integer_int8", - 65: "required_double_array_integer_uint", - 66: "required_double_array_integer_uint16", - 67: "required_double_array_integer_uint32", - 68: "required_double_array_integer_uint64", - 69: "required_double_array_integer_uint8", - 70: "required_double_array_integer_unix", - 71: "required_double_array_integer_unix-micro", - 72: "required_double_array_integer_unix-milli", - 73: "required_double_array_integer_unix-nano", - 74: "required_double_array_integer_unix-seconds", - 75: "required_double_array_null", - 76: "required_double_array_number", - 77: "required_double_array_number_double", - 78: "required_double_array_number_float", - 79: "required_double_array_number_int32", - 80: "required_double_array_number_int64", - 81: "required_double_array_string", - 82: "required_double_array_string_base64", - 83: "required_double_array_string_binary", - 84: "required_double_array_string_byte", - 85: "required_double_array_string_date", - 86: "required_double_array_string_date-time", - 87: "required_double_array_string_duration", - 88: "required_double_array_string_email", - 89: "required_double_array_string_float32", - 90: "required_double_array_string_float64", - 91: "required_double_array_string_hostname", - 92: "required_double_array_string_int", - 93: "required_double_array_string_int16", - 94: "required_double_array_string_int32", - 95: "required_double_array_string_int64", - 96: "required_double_array_string_int8", - 97: "required_double_array_string_ip", - 98: "required_double_array_string_ipv4", - 99: "required_double_array_string_ipv6", - 100: "required_double_array_string_password", - 101: "required_double_array_string_time", - 102: "required_double_array_string_uint", - 103: "required_double_array_string_uint16", - 104: "required_double_array_string_uint32", - 105: "required_double_array_string_uint64", - 106: "required_double_array_string_uint8", - 107: "required_double_array_string_unix", - 108: "required_double_array_string_unix-micro", - 109: "required_double_array_string_unix-milli", - 110: "required_double_array_string_unix-nano", - 111: "required_double_array_string_unix-seconds", - 112: "required_double_array_string_uri", - 113: "required_double_array_string_uuid", - 114: "required_integer", - 115: "required_integer_int16", - 116: "required_integer_int32", - 117: "required_integer_int64", - 118: "required_integer_int8", - 119: "required_integer_uint", - 120: "required_integer_uint16", - 121: "required_integer_uint32", - 122: "required_integer_uint64", - 123: "required_integer_uint8", - 124: "required_integer_unix", - 125: "required_integer_unix-micro", - 126: "required_integer_unix-milli", - 127: "required_integer_unix-nano", - 128: "required_integer_unix-seconds", - 129: "required_null", - 130: "required_number", - 131: "required_number_double", - 132: "required_number_float", - 133: "required_number_int32", - 134: "required_number_int64", - 135: "required_string", - 136: "required_string_base64", - 137: "required_string_binary", - 138: "required_string_byte", - 139: "required_string_date", - 140: "required_string_date-time", - 141: "required_string_duration", - 142: "required_string_email", - 143: "required_string_float32", - 144: "required_string_float64", - 145: "required_string_hostname", - 146: "required_string_int", - 147: "required_string_int16", - 148: "required_string_int32", - 149: "required_string_int64", - 150: "required_string_int8", - 151: "required_string_ip", - 152: "required_string_ipv4", - 153: "required_string_ipv6", - 154: "required_string_password", - 155: "required_string_time", - 156: "required_string_uint", - 157: "required_string_uint16", - 158: "required_string_uint32", - 159: "required_string_uint64", - 160: "required_string_uint8", - 161: "required_string_unix", - 162: "required_string_unix-micro", - 163: "required_string_unix-milli", - 164: "required_string_unix-nano", - 165: "required_string_unix-seconds", - 166: "required_string_uri", - 167: "required_string_uuid", - 168: "optional_any", - 169: "optional_array_any", - 170: "optional_array_boolean", - 171: "optional_array_integer", - 172: "optional_array_integer_int16", - 173: "optional_array_integer_int32", - 174: "optional_array_integer_int64", - 175: "optional_array_integer_int8", - 176: "optional_array_integer_uint", - 177: "optional_array_integer_uint16", - 178: "optional_array_integer_uint32", - 179: "optional_array_integer_uint64", - 180: "optional_array_integer_uint8", - 181: "optional_array_integer_unix", - 182: "optional_array_integer_unix-micro", - 183: "optional_array_integer_unix-milli", - 184: "optional_array_integer_unix-nano", - 185: "optional_array_integer_unix-seconds", - 186: "optional_array_null", - 187: "optional_array_number", - 188: "optional_array_number_double", - 189: "optional_array_number_float", - 190: "optional_array_number_int32", - 191: "optional_array_number_int64", - 192: "optional_array_string", - 193: "optional_array_string_base64", - 194: "optional_array_string_binary", - 195: "optional_array_string_byte", - 196: "optional_array_string_date", - 197: "optional_array_string_date-time", - 198: "optional_array_string_duration", - 199: "optional_array_string_email", - 200: "optional_array_string_float32", - 201: "optional_array_string_float64", - 202: "optional_array_string_hostname", - 203: "optional_array_string_int", - 204: "optional_array_string_int16", - 205: "optional_array_string_int32", - 206: "optional_array_string_int64", - 207: "optional_array_string_int8", - 208: "optional_array_string_ip", - 209: "optional_array_string_ipv4", - 210: "optional_array_string_ipv6", - 211: "optional_array_string_password", - 212: "optional_array_string_time", - 213: "optional_array_string_uint", - 214: "optional_array_string_uint16", - 215: "optional_array_string_uint32", - 216: "optional_array_string_uint64", - 217: "optional_array_string_uint8", - 218: "optional_array_string_unix", - 219: "optional_array_string_unix-micro", - 220: "optional_array_string_unix-milli", - 221: "optional_array_string_unix-nano", - 222: "optional_array_string_unix-seconds", - 223: "optional_array_string_uri", - 224: "optional_array_string_uuid", - 225: "optional_boolean", - 226: "optional_double_array_any", - 227: "optional_double_array_boolean", - 228: "optional_double_array_integer", - 229: "optional_double_array_integer_int16", - 230: "optional_double_array_integer_int32", - 231: "optional_double_array_integer_int64", - 232: "optional_double_array_integer_int8", - 233: "optional_double_array_integer_uint", - 234: "optional_double_array_integer_uint16", - 235: "optional_double_array_integer_uint32", - 236: "optional_double_array_integer_uint64", - 237: "optional_double_array_integer_uint8", - 238: "optional_double_array_integer_unix", - 239: "optional_double_array_integer_unix-micro", - 240: "optional_double_array_integer_unix-milli", - 241: "optional_double_array_integer_unix-nano", - 242: "optional_double_array_integer_unix-seconds", - 243: "optional_double_array_null", - 244: "optional_double_array_number", - 245: "optional_double_array_number_double", - 246: "optional_double_array_number_float", - 247: "optional_double_array_number_int32", - 248: "optional_double_array_number_int64", - 249: "optional_double_array_string", - 250: "optional_double_array_string_base64", - 251: "optional_double_array_string_binary", - 252: "optional_double_array_string_byte", - 253: "optional_double_array_string_date", - 254: "optional_double_array_string_date-time", - 255: "optional_double_array_string_duration", - 256: "optional_double_array_string_email", - 257: "optional_double_array_string_float32", - 258: "optional_double_array_string_float64", - 259: "optional_double_array_string_hostname", - 260: "optional_double_array_string_int", - 261: "optional_double_array_string_int16", - 262: "optional_double_array_string_int32", - 263: "optional_double_array_string_int64", - 264: "optional_double_array_string_int8", - 265: "optional_double_array_string_ip", - 266: "optional_double_array_string_ipv4", - 267: "optional_double_array_string_ipv6", - 268: "optional_double_array_string_password", - 269: "optional_double_array_string_time", - 270: "optional_double_array_string_uint", - 271: "optional_double_array_string_uint16", - 272: "optional_double_array_string_uint32", - 273: "optional_double_array_string_uint64", - 274: "optional_double_array_string_uint8", - 275: "optional_double_array_string_unix", - 276: "optional_double_array_string_unix-micro", - 277: "optional_double_array_string_unix-milli", - 278: "optional_double_array_string_unix-nano", - 279: "optional_double_array_string_unix-seconds", - 280: "optional_double_array_string_uri", - 281: "optional_double_array_string_uuid", - 282: "optional_integer", - 283: "optional_integer_int16", - 284: "optional_integer_int32", - 285: "optional_integer_int64", - 286: "optional_integer_int8", - 287: "optional_integer_uint", - 288: "optional_integer_uint16", - 289: "optional_integer_uint32", - 290: "optional_integer_uint64", - 291: "optional_integer_uint8", - 292: "optional_integer_unix", - 293: "optional_integer_unix-micro", - 294: "optional_integer_unix-milli", - 295: "optional_integer_unix-nano", - 296: "optional_integer_unix-seconds", - 297: "optional_null", - 298: "optional_number", - 299: "optional_number_double", - 300: "optional_number_float", - 301: "optional_number_int32", - 302: "optional_number_int64", - 303: "optional_string", - 304: "optional_string_base64", - 305: "optional_string_binary", - 306: "optional_string_byte", - 307: "optional_string_date", - 308: "optional_string_date-time", - 309: "optional_string_duration", - 310: "optional_string_email", - 311: "optional_string_float32", - 312: "optional_string_float64", - 313: "optional_string_hostname", - 314: "optional_string_int", - 315: "optional_string_int16", - 316: "optional_string_int32", - 317: "optional_string_int64", - 318: "optional_string_int8", - 319: "optional_string_ip", - 320: "optional_string_ipv4", - 321: "optional_string_ipv6", - 322: "optional_string_password", - 323: "optional_string_time", - 324: "optional_string_uint", - 325: "optional_string_uint16", - 326: "optional_string_uint32", - 327: "optional_string_uint64", - 328: "optional_string_uint8", - 329: "optional_string_unix", - 330: "optional_string_unix-micro", - 331: "optional_string_unix-milli", - 332: "optional_string_unix-nano", - 333: "optional_string_unix-seconds", - 334: "optional_string_uri", - 335: "optional_string_uuid", + 43: "required_array_string_mac", + 44: "required_array_string_password", + 45: "required_array_string_time", + 46: "required_array_string_uint", + 47: "required_array_string_uint16", + 48: "required_array_string_uint32", + 49: "required_array_string_uint64", + 50: "required_array_string_uint8", + 51: "required_array_string_unix", + 52: "required_array_string_unix-micro", + 53: "required_array_string_unix-milli", + 54: "required_array_string_unix-nano", + 55: "required_array_string_unix-seconds", + 56: "required_array_string_uri", + 57: "required_array_string_uuid", + 58: "required_boolean", + 59: "required_double_array_any", + 60: "required_double_array_boolean", + 61: "required_double_array_integer", + 62: "required_double_array_integer_int16", + 63: "required_double_array_integer_int32", + 64: "required_double_array_integer_int64", + 65: "required_double_array_integer_int8", + 66: "required_double_array_integer_uint", + 67: "required_double_array_integer_uint16", + 68: "required_double_array_integer_uint32", + 69: "required_double_array_integer_uint64", + 70: "required_double_array_integer_uint8", + 71: "required_double_array_integer_unix", + 72: "required_double_array_integer_unix-micro", + 73: "required_double_array_integer_unix-milli", + 74: "required_double_array_integer_unix-nano", + 75: "required_double_array_integer_unix-seconds", + 76: "required_double_array_null", + 77: "required_double_array_number", + 78: "required_double_array_number_double", + 79: "required_double_array_number_float", + 80: "required_double_array_number_int32", + 81: "required_double_array_number_int64", + 82: "required_double_array_string", + 83: "required_double_array_string_base64", + 84: "required_double_array_string_binary", + 85: "required_double_array_string_byte", + 86: "required_double_array_string_date", + 87: "required_double_array_string_date-time", + 88: "required_double_array_string_duration", + 89: "required_double_array_string_email", + 90: "required_double_array_string_float32", + 91: "required_double_array_string_float64", + 92: "required_double_array_string_hostname", + 93: "required_double_array_string_int", + 94: "required_double_array_string_int16", + 95: "required_double_array_string_int32", + 96: "required_double_array_string_int64", + 97: "required_double_array_string_int8", + 98: "required_double_array_string_ip", + 99: "required_double_array_string_ipv4", + 100: "required_double_array_string_ipv6", + 101: "required_double_array_string_mac", + 102: "required_double_array_string_password", + 103: "required_double_array_string_time", + 104: "required_double_array_string_uint", + 105: "required_double_array_string_uint16", + 106: "required_double_array_string_uint32", + 107: "required_double_array_string_uint64", + 108: "required_double_array_string_uint8", + 109: "required_double_array_string_unix", + 110: "required_double_array_string_unix-micro", + 111: "required_double_array_string_unix-milli", + 112: "required_double_array_string_unix-nano", + 113: "required_double_array_string_unix-seconds", + 114: "required_double_array_string_uri", + 115: "required_double_array_string_uuid", + 116: "required_integer", + 117: "required_integer_int16", + 118: "required_integer_int32", + 119: "required_integer_int64", + 120: "required_integer_int8", + 121: "required_integer_uint", + 122: "required_integer_uint16", + 123: "required_integer_uint32", + 124: "required_integer_uint64", + 125: "required_integer_uint8", + 126: "required_integer_unix", + 127: "required_integer_unix-micro", + 128: "required_integer_unix-milli", + 129: "required_integer_unix-nano", + 130: "required_integer_unix-seconds", + 131: "required_null", + 132: "required_number", + 133: "required_number_double", + 134: "required_number_float", + 135: "required_number_int32", + 136: "required_number_int64", + 137: "required_string", + 138: "required_string_base64", + 139: "required_string_binary", + 140: "required_string_byte", + 141: "required_string_date", + 142: "required_string_date-time", + 143: "required_string_duration", + 144: "required_string_email", + 145: "required_string_float32", + 146: "required_string_float64", + 147: "required_string_hostname", + 148: "required_string_int", + 149: "required_string_int16", + 150: "required_string_int32", + 151: "required_string_int64", + 152: "required_string_int8", + 153: "required_string_ip", + 154: "required_string_ipv4", + 155: "required_string_ipv6", + 156: "required_string_mac", + 157: "required_string_password", + 158: "required_string_time", + 159: "required_string_uint", + 160: "required_string_uint16", + 161: "required_string_uint32", + 162: "required_string_uint64", + 163: "required_string_uint8", + 164: "required_string_unix", + 165: "required_string_unix-micro", + 166: "required_string_unix-milli", + 167: "required_string_unix-nano", + 168: "required_string_unix-seconds", + 169: "required_string_uri", + 170: "required_string_uuid", + 171: "optional_any", + 172: "optional_array_any", + 173: "optional_array_boolean", + 174: "optional_array_integer", + 175: "optional_array_integer_int16", + 176: "optional_array_integer_int32", + 177: "optional_array_integer_int64", + 178: "optional_array_integer_int8", + 179: "optional_array_integer_uint", + 180: "optional_array_integer_uint16", + 181: "optional_array_integer_uint32", + 182: "optional_array_integer_uint64", + 183: "optional_array_integer_uint8", + 184: "optional_array_integer_unix", + 185: "optional_array_integer_unix-micro", + 186: "optional_array_integer_unix-milli", + 187: "optional_array_integer_unix-nano", + 188: "optional_array_integer_unix-seconds", + 189: "optional_array_null", + 190: "optional_array_number", + 191: "optional_array_number_double", + 192: "optional_array_number_float", + 193: "optional_array_number_int32", + 194: "optional_array_number_int64", + 195: "optional_array_string", + 196: "optional_array_string_base64", + 197: "optional_array_string_binary", + 198: "optional_array_string_byte", + 199: "optional_array_string_date", + 200: "optional_array_string_date-time", + 201: "optional_array_string_duration", + 202: "optional_array_string_email", + 203: "optional_array_string_float32", + 204: "optional_array_string_float64", + 205: "optional_array_string_hostname", + 206: "optional_array_string_int", + 207: "optional_array_string_int16", + 208: "optional_array_string_int32", + 209: "optional_array_string_int64", + 210: "optional_array_string_int8", + 211: "optional_array_string_ip", + 212: "optional_array_string_ipv4", + 213: "optional_array_string_ipv6", + 214: "optional_array_string_mac", + 215: "optional_array_string_password", + 216: "optional_array_string_time", + 217: "optional_array_string_uint", + 218: "optional_array_string_uint16", + 219: "optional_array_string_uint32", + 220: "optional_array_string_uint64", + 221: "optional_array_string_uint8", + 222: "optional_array_string_unix", + 223: "optional_array_string_unix-micro", + 224: "optional_array_string_unix-milli", + 225: "optional_array_string_unix-nano", + 226: "optional_array_string_unix-seconds", + 227: "optional_array_string_uri", + 228: "optional_array_string_uuid", + 229: "optional_boolean", + 230: "optional_double_array_any", + 231: "optional_double_array_boolean", + 232: "optional_double_array_integer", + 233: "optional_double_array_integer_int16", + 234: "optional_double_array_integer_int32", + 235: "optional_double_array_integer_int64", + 236: "optional_double_array_integer_int8", + 237: "optional_double_array_integer_uint", + 238: "optional_double_array_integer_uint16", + 239: "optional_double_array_integer_uint32", + 240: "optional_double_array_integer_uint64", + 241: "optional_double_array_integer_uint8", + 242: "optional_double_array_integer_unix", + 243: "optional_double_array_integer_unix-micro", + 244: "optional_double_array_integer_unix-milli", + 245: "optional_double_array_integer_unix-nano", + 246: "optional_double_array_integer_unix-seconds", + 247: "optional_double_array_null", + 248: "optional_double_array_number", + 249: "optional_double_array_number_double", + 250: "optional_double_array_number_float", + 251: "optional_double_array_number_int32", + 252: "optional_double_array_number_int64", + 253: "optional_double_array_string", + 254: "optional_double_array_string_base64", + 255: "optional_double_array_string_binary", + 256: "optional_double_array_string_byte", + 257: "optional_double_array_string_date", + 258: "optional_double_array_string_date-time", + 259: "optional_double_array_string_duration", + 260: "optional_double_array_string_email", + 261: "optional_double_array_string_float32", + 262: "optional_double_array_string_float64", + 263: "optional_double_array_string_hostname", + 264: "optional_double_array_string_int", + 265: "optional_double_array_string_int16", + 266: "optional_double_array_string_int32", + 267: "optional_double_array_string_int64", + 268: "optional_double_array_string_int8", + 269: "optional_double_array_string_ip", + 270: "optional_double_array_string_ipv4", + 271: "optional_double_array_string_ipv6", + 272: "optional_double_array_string_mac", + 273: "optional_double_array_string_password", + 274: "optional_double_array_string_time", + 275: "optional_double_array_string_uint", + 276: "optional_double_array_string_uint16", + 277: "optional_double_array_string_uint32", + 278: "optional_double_array_string_uint64", + 279: "optional_double_array_string_uint8", + 280: "optional_double_array_string_unix", + 281: "optional_double_array_string_unix-micro", + 282: "optional_double_array_string_unix-milli", + 283: "optional_double_array_string_unix-nano", + 284: "optional_double_array_string_unix-seconds", + 285: "optional_double_array_string_uri", + 286: "optional_double_array_string_uuid", + 287: "optional_integer", + 288: "optional_integer_int16", + 289: "optional_integer_int32", + 290: "optional_integer_int64", + 291: "optional_integer_int8", + 292: "optional_integer_uint", + 293: "optional_integer_uint16", + 294: "optional_integer_uint32", + 295: "optional_integer_uint64", + 296: "optional_integer_uint8", + 297: "optional_integer_unix", + 298: "optional_integer_unix-micro", + 299: "optional_integer_unix-milli", + 300: "optional_integer_unix-nano", + 301: "optional_integer_unix-seconds", + 302: "optional_null", + 303: "optional_number", + 304: "optional_number_double", + 305: "optional_number_float", + 306: "optional_number_int32", + 307: "optional_number_int64", + 308: "optional_string", + 309: "optional_string_base64", + 310: "optional_string_binary", + 311: "optional_string_byte", + 312: "optional_string_date", + 313: "optional_string_date-time", + 314: "optional_string_duration", + 315: "optional_string_email", + 316: "optional_string_float32", + 317: "optional_string_float64", + 318: "optional_string_hostname", + 319: "optional_string_int", + 320: "optional_string_int16", + 321: "optional_string_int32", + 322: "optional_string_int64", + 323: "optional_string_int8", + 324: "optional_string_ip", + 325: "optional_string_ipv4", + 326: "optional_string_ipv6", + 327: "optional_string_mac", + 328: "optional_string_password", + 329: "optional_string_time", + 330: "optional_string_uint", + 331: "optional_string_uint16", + 332: "optional_string_uint32", + 333: "optional_string_uint64", + 334: "optional_string_uint8", + 335: "optional_string_unix", + 336: "optional_string_unix-micro", + 337: "optional_string_unix-milli", + 338: "optional_string_unix-nano", + 339: "optional_string_unix-seconds", + 340: "optional_string_uri", + 341: "optional_string_uuid", } // Decode decodes TestResponseFormatTestOK from json. @@ -29372,7 +29919,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode TestResponseFormatTestOK to nil") } - var requiredBitSet [42]uint8 + var requiredBitSet [43]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -30226,8 +30773,28 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_array_string_ipv6\"") } - case "required_array_string_password": + case "required_array_string_mac": requiredBitSet[5] |= 1 << 3 + if err := func() error { + s.RequiredArrayStringMAC = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { + return err + } + s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_array_string_mac\"") + } + case "required_array_string_password": + requiredBitSet[5] |= 1 << 4 if err := func() error { s.RequiredArrayStringPassword = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30247,7 +30814,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[5] |= 1 << 4 + requiredBitSet[5] |= 1 << 5 if err := func() error { s.RequiredArrayStringTime = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30267,7 +30834,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_time\"") } case "required_array_string_uint": - requiredBitSet[5] |= 1 << 5 + requiredBitSet[5] |= 1 << 6 if err := func() error { s.RequiredArrayStringUint = make([]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30287,7 +30854,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint\"") } case "required_array_string_uint16": - requiredBitSet[5] |= 1 << 6 + requiredBitSet[5] |= 1 << 7 if err := func() error { s.RequiredArrayStringUint16 = make([]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30307,7 +30874,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint16\"") } case "required_array_string_uint32": - requiredBitSet[5] |= 1 << 7 + requiredBitSet[6] |= 1 << 0 if err := func() error { s.RequiredArrayStringUint32 = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30327,7 +30894,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint32\"") } case "required_array_string_uint64": - requiredBitSet[6] |= 1 << 0 + requiredBitSet[6] |= 1 << 1 if err := func() error { s.RequiredArrayStringUint64 = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30347,7 +30914,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint64\"") } case "required_array_string_uint8": - requiredBitSet[6] |= 1 << 1 + requiredBitSet[6] |= 1 << 2 if err := func() error { s.RequiredArrayStringUint8 = make([]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30367,7 +30934,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uint8\"") } case "required_array_string_unix": - requiredBitSet[6] |= 1 << 2 + requiredBitSet[6] |= 1 << 3 if err := func() error { s.RequiredArrayStringUnix = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30387,7 +30954,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[6] |= 1 << 3 + requiredBitSet[6] |= 1 << 4 if err := func() error { s.RequiredArrayStringUnixMinusMicro = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30407,7 +30974,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[6] |= 1 << 4 + requiredBitSet[6] |= 1 << 5 if err := func() error { s.RequiredArrayStringUnixMinusMilli = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30427,7 +30994,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[6] |= 1 << 5 + requiredBitSet[6] |= 1 << 6 if err := func() error { s.RequiredArrayStringUnixMinusNano = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30447,7 +31014,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[6] |= 1 << 6 + requiredBitSet[6] |= 1 << 7 if err := func() error { s.RequiredArrayStringUnixMinusSeconds = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30467,7 +31034,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[6] |= 1 << 7 + requiredBitSet[7] |= 1 << 0 if err := func() error { s.RequiredArrayStringURI = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30487,7 +31054,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[7] |= 1 << 0 + requiredBitSet[7] |= 1 << 1 if err := func() error { s.RequiredArrayStringUUID = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30507,7 +31074,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_array_string_uuid\"") } case "required_boolean": - requiredBitSet[7] |= 1 << 1 + requiredBitSet[7] |= 1 << 2 if err := func() error { v, err := d.Bool() s.RequiredBoolean = bool(v) @@ -30519,7 +31086,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_boolean\"") } case "required_double_array_any": - requiredBitSet[7] |= 1 << 2 + requiredBitSet[7] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayAny = make([][]jx.Raw, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30547,7 +31114,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[7] |= 1 << 3 + requiredBitSet[7] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayBoolean = make([][]bool, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30575,7 +31142,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[7] |= 1 << 4 + requiredBitSet[7] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayInteger = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30603,7 +31170,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer\"") } case "required_double_array_integer_int16": - requiredBitSet[7] |= 1 << 5 + requiredBitSet[7] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerInt16 = make([][]int16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30631,7 +31198,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int16\"") } case "required_double_array_integer_int32": - requiredBitSet[7] |= 1 << 6 + requiredBitSet[7] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30659,7 +31226,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[7] |= 1 << 7 + requiredBitSet[8] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayIntegerInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30687,7 +31254,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int64\"") } case "required_double_array_integer_int8": - requiredBitSet[8] |= 1 << 0 + requiredBitSet[8] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayIntegerInt8 = make([][]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30715,7 +31282,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_int8\"") } case "required_double_array_integer_uint": - requiredBitSet[8] |= 1 << 1 + requiredBitSet[8] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayIntegerUint = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30743,7 +31310,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint\"") } case "required_double_array_integer_uint16": - requiredBitSet[8] |= 1 << 2 + requiredBitSet[8] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUint16 = make([][]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30771,7 +31338,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint16\"") } case "required_double_array_integer_uint32": - requiredBitSet[8] |= 1 << 3 + requiredBitSet[8] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayIntegerUint32 = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30799,7 +31366,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint32\"") } case "required_double_array_integer_uint64": - requiredBitSet[8] |= 1 << 4 + requiredBitSet[8] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayIntegerUint64 = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30827,7 +31394,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint64\"") } case "required_double_array_integer_uint8": - requiredBitSet[8] |= 1 << 5 + requiredBitSet[8] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayIntegerUint8 = make([][]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30855,7 +31422,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_integer_uint8\"") } case "required_double_array_integer_unix": - requiredBitSet[8] |= 1 << 6 + requiredBitSet[8] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayIntegerUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30883,7 +31450,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[8] |= 1 << 7 + requiredBitSet[9] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30911,7 +31478,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[9] |= 1 << 0 + requiredBitSet[9] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30939,7 +31506,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[9] |= 1 << 1 + requiredBitSet[9] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30967,7 +31534,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[9] |= 1 << 2 + requiredBitSet[9] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayIntegerUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -30995,7 +31562,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[9] |= 1 << 3 + requiredBitSet[9] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayNull = make([][]struct{}, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31021,7 +31588,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[9] |= 1 << 4 + requiredBitSet[9] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayNumber = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31049,7 +31616,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[9] |= 1 << 5 + requiredBitSet[9] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayNumberDouble = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31077,7 +31644,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[9] |= 1 << 6 + requiredBitSet[9] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayNumberFloat = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31105,7 +31672,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[9] |= 1 << 7 + requiredBitSet[10] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayNumberInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31133,7 +31700,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[10] |= 1 << 0 + requiredBitSet[10] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayNumberInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31161,7 +31728,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[10] |= 1 << 1 + requiredBitSet[10] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayString = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31189,7 +31756,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string\"") } case "required_double_array_string_base64": - requiredBitSet[10] |= 1 << 2 + requiredBitSet[10] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringBase64 = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31217,7 +31784,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_base64\"") } case "required_double_array_string_binary": - requiredBitSet[10] |= 1 << 3 + requiredBitSet[10] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringBinary = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31245,7 +31812,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[10] |= 1 << 4 + requiredBitSet[10] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringByte = make([][][]byte, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31273,7 +31840,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[10] |= 1 << 5 + requiredBitSet[10] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringDate = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31301,7 +31868,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[10] |= 1 << 6 + requiredBitSet[10] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringDateMinusTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31329,7 +31896,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[10] |= 1 << 7 + requiredBitSet[11] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringDuration = make([][]time.Duration, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31357,7 +31924,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[11] |= 1 << 0 + requiredBitSet[11] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringEmail = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31385,7 +31952,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_float32": - requiredBitSet[11] |= 1 << 1 + requiredBitSet[11] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringFloat32 = make([][]float32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31413,7 +31980,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_float32\"") } case "required_double_array_string_float64": - requiredBitSet[11] |= 1 << 2 + requiredBitSet[11] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringFloat64 = make([][]float64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31441,7 +32008,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_float64\"") } case "required_double_array_string_hostname": - requiredBitSet[11] |= 1 << 3 + requiredBitSet[11] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringHostname = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31469,7 +32036,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_int": - requiredBitSet[11] |= 1 << 4 + requiredBitSet[11] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringInt = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31497,7 +32064,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int\"") } case "required_double_array_string_int16": - requiredBitSet[11] |= 1 << 5 + requiredBitSet[11] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringInt16 = make([][]int16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31525,7 +32092,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int16\"") } case "required_double_array_string_int32": - requiredBitSet[11] |= 1 << 6 + requiredBitSet[11] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringInt32 = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31553,7 +32120,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[11] |= 1 << 7 + requiredBitSet[12] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringInt64 = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31581,7 +32148,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_int8": - requiredBitSet[12] |= 1 << 0 + requiredBitSet[12] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringInt8 = make([][]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31609,7 +32176,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_int8\"") } case "required_double_array_string_ip": - requiredBitSet[12] |= 1 << 1 + requiredBitSet[12] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringIP = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31637,7 +32204,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[12] |= 1 << 2 + requiredBitSet[12] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringIpv4 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31665,7 +32232,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[12] |= 1 << 3 + requiredBitSet[12] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringIpv6 = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31692,8 +32259,36 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_double_array_string_ipv6\"") } + case "required_double_array_string_mac": + requiredBitSet[12] |= 1 << 5 + if err := func() error { + s.RequiredDoubleArrayStringMAC = make([][]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.RequiredDoubleArrayStringMAC = append(s.RequiredDoubleArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_double_array_string_mac\"") + } case "required_double_array_string_password": - requiredBitSet[12] |= 1 << 4 + requiredBitSet[12] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringPassword = make([][]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31721,7 +32316,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[12] |= 1 << 5 + requiredBitSet[12] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringTime = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31749,7 +32344,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_uint": - requiredBitSet[12] |= 1 << 6 + requiredBitSet[13] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUint = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31777,7 +32372,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint\"") } case "required_double_array_string_uint16": - requiredBitSet[12] |= 1 << 7 + requiredBitSet[13] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUint16 = make([][]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31805,7 +32400,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint16\"") } case "required_double_array_string_uint32": - requiredBitSet[13] |= 1 << 0 + requiredBitSet[13] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringUint32 = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31833,7 +32428,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint32\"") } case "required_double_array_string_uint64": - requiredBitSet[13] |= 1 << 1 + requiredBitSet[13] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUint64 = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31861,7 +32456,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint64\"") } case "required_double_array_string_uint8": - requiredBitSet[13] |= 1 << 2 + requiredBitSet[13] |= 1 << 4 if err := func() error { s.RequiredDoubleArrayStringUint8 = make([][]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31889,7 +32484,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uint8\"") } case "required_double_array_string_unix": - requiredBitSet[13] |= 1 << 3 + requiredBitSet[13] |= 1 << 5 if err := func() error { s.RequiredDoubleArrayStringUnix = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31917,7 +32512,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[13] |= 1 << 4 + requiredBitSet[13] |= 1 << 6 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMicro = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31945,7 +32540,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[13] |= 1 << 5 + requiredBitSet[13] |= 1 << 7 if err := func() error { s.RequiredDoubleArrayStringUnixMinusMilli = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -31973,7 +32568,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[13] |= 1 << 6 + requiredBitSet[14] |= 1 << 0 if err := func() error { s.RequiredDoubleArrayStringUnixMinusNano = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -32001,7 +32596,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[13] |= 1 << 7 + requiredBitSet[14] |= 1 << 1 if err := func() error { s.RequiredDoubleArrayStringUnixMinusSeconds = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -32029,7 +32624,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[14] |= 1 << 0 + requiredBitSet[14] |= 1 << 2 if err := func() error { s.RequiredDoubleArrayStringURI = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -32057,7 +32652,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[14] |= 1 << 1 + requiredBitSet[14] |= 1 << 3 if err := func() error { s.RequiredDoubleArrayStringUUID = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -32085,7 +32680,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_double_array_string_uuid\"") } case "required_integer": - requiredBitSet[14] |= 1 << 2 + requiredBitSet[14] |= 1 << 4 if err := func() error { v, err := d.Int() s.RequiredInteger = int(v) @@ -32097,7 +32692,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer\"") } case "required_integer_int16": - requiredBitSet[14] |= 1 << 3 + requiredBitSet[14] |= 1 << 5 if err := func() error { v, err := d.Int16() s.RequiredIntegerInt16 = int16(v) @@ -32109,7 +32704,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int16\"") } case "required_integer_int32": - requiredBitSet[14] |= 1 << 4 + requiredBitSet[14] |= 1 << 6 if err := func() error { v, err := d.Int32() s.RequiredIntegerInt32 = int32(v) @@ -32121,7 +32716,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int32\"") } case "required_integer_int64": - requiredBitSet[14] |= 1 << 5 + requiredBitSet[14] |= 1 << 7 if err := func() error { v, err := d.Int64() s.RequiredIntegerInt64 = int64(v) @@ -32133,7 +32728,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int64\"") } case "required_integer_int8": - requiredBitSet[14] |= 1 << 6 + requiredBitSet[15] |= 1 << 0 if err := func() error { v, err := d.Int8() s.RequiredIntegerInt8 = int8(v) @@ -32145,7 +32740,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_int8\"") } case "required_integer_uint": - requiredBitSet[14] |= 1 << 7 + requiredBitSet[15] |= 1 << 1 if err := func() error { v, err := d.UInt() s.RequiredIntegerUint = uint(v) @@ -32157,7 +32752,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint\"") } case "required_integer_uint16": - requiredBitSet[15] |= 1 << 0 + requiredBitSet[15] |= 1 << 2 if err := func() error { v, err := d.UInt16() s.RequiredIntegerUint16 = uint16(v) @@ -32169,7 +32764,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint16\"") } case "required_integer_uint32": - requiredBitSet[15] |= 1 << 1 + requiredBitSet[15] |= 1 << 3 if err := func() error { v, err := d.UInt32() s.RequiredIntegerUint32 = uint32(v) @@ -32181,7 +32776,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint32\"") } case "required_integer_uint64": - requiredBitSet[15] |= 1 << 2 + requiredBitSet[15] |= 1 << 4 if err := func() error { v, err := d.UInt64() s.RequiredIntegerUint64 = uint64(v) @@ -32193,7 +32788,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint64\"") } case "required_integer_uint8": - requiredBitSet[15] |= 1 << 3 + requiredBitSet[15] |= 1 << 5 if err := func() error { v, err := d.UInt8() s.RequiredIntegerUint8 = uint8(v) @@ -32205,7 +32800,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_uint8\"") } case "required_integer_unix": - requiredBitSet[15] |= 1 << 4 + requiredBitSet[15] |= 1 << 6 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnix = v @@ -32217,7 +32812,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix\"") } case "required_integer_unix-micro": - requiredBitSet[15] |= 1 << 5 + requiredBitSet[15] |= 1 << 7 if err := func() error { v, err := json.DecodeUnixMicro(d) s.RequiredIntegerUnixMinusMicro = v @@ -32229,7 +32824,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[15] |= 1 << 6 + requiredBitSet[16] |= 1 << 0 if err := func() error { v, err := json.DecodeUnixMilli(d) s.RequiredIntegerUnixMinusMilli = v @@ -32241,7 +32836,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[15] |= 1 << 7 + requiredBitSet[16] |= 1 << 1 if err := func() error { v, err := json.DecodeUnixNano(d) s.RequiredIntegerUnixMinusNano = v @@ -32253,7 +32848,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[16] |= 1 << 0 + requiredBitSet[16] |= 1 << 2 if err := func() error { v, err := json.DecodeUnixSeconds(d) s.RequiredIntegerUnixMinusSeconds = v @@ -32265,7 +32860,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_integer_unix-seconds\"") } case "required_null": - requiredBitSet[16] |= 1 << 1 + requiredBitSet[16] |= 1 << 3 if err := func() error { if err := d.Null(); err != nil { return err @@ -32275,7 +32870,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_null\"") } case "required_number": - requiredBitSet[16] |= 1 << 2 + requiredBitSet[16] |= 1 << 4 if err := func() error { v, err := d.Float64() s.RequiredNumber = float64(v) @@ -32287,7 +32882,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number\"") } case "required_number_double": - requiredBitSet[16] |= 1 << 3 + requiredBitSet[16] |= 1 << 5 if err := func() error { v, err := d.Float64() s.RequiredNumberDouble = float64(v) @@ -32299,7 +32894,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_double\"") } case "required_number_float": - requiredBitSet[16] |= 1 << 4 + requiredBitSet[16] |= 1 << 6 if err := func() error { v, err := d.Float32() s.RequiredNumberFloat = float32(v) @@ -32311,7 +32906,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_float\"") } case "required_number_int32": - requiredBitSet[16] |= 1 << 5 + requiredBitSet[16] |= 1 << 7 if err := func() error { v, err := d.Int32() s.RequiredNumberInt32 = int32(v) @@ -32323,7 +32918,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int32\"") } case "required_number_int64": - requiredBitSet[16] |= 1 << 6 + requiredBitSet[17] |= 1 << 0 if err := func() error { v, err := d.Int64() s.RequiredNumberInt64 = int64(v) @@ -32335,7 +32930,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_number_int64\"") } case "required_string": - requiredBitSet[16] |= 1 << 7 + requiredBitSet[17] |= 1 << 1 if err := func() error { v, err := d.Str() s.RequiredString = string(v) @@ -32347,7 +32942,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string\"") } case "required_string_base64": - requiredBitSet[17] |= 1 << 0 + requiredBitSet[17] |= 1 << 2 if err := func() error { v, err := d.Base64() s.RequiredStringBase64 = []byte(v) @@ -32359,7 +32954,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_base64\"") } case "required_string_binary": - requiredBitSet[17] |= 1 << 1 + requiredBitSet[17] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringBinary = string(v) @@ -32371,7 +32966,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_binary\"") } case "required_string_byte": - requiredBitSet[17] |= 1 << 2 + requiredBitSet[17] |= 1 << 4 if err := func() error { v, err := d.Base64() s.RequiredStringByte = []byte(v) @@ -32383,7 +32978,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_byte\"") } case "required_string_date": - requiredBitSet[17] |= 1 << 3 + requiredBitSet[17] |= 1 << 5 if err := func() error { v, err := json.DecodeDate(d) s.RequiredStringDate = v @@ -32395,7 +32990,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date\"") } case "required_string_date-time": - requiredBitSet[17] |= 1 << 4 + requiredBitSet[17] |= 1 << 6 if err := func() error { v, err := json.DecodeDateTime(d) s.RequiredStringDateMinusTime = v @@ -32407,7 +33002,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_date-time\"") } case "required_string_duration": - requiredBitSet[17] |= 1 << 5 + requiredBitSet[17] |= 1 << 7 if err := func() error { v, err := json.DecodeDuration(d) s.RequiredStringDuration = v @@ -32419,7 +33014,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_duration\"") } case "required_string_email": - requiredBitSet[17] |= 1 << 6 + requiredBitSet[18] |= 1 << 0 if err := func() error { v, err := d.Str() s.RequiredStringEmail = string(v) @@ -32431,7 +33026,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_email\"") } case "required_string_float32": - requiredBitSet[17] |= 1 << 7 + requiredBitSet[18] |= 1 << 1 if err := func() error { v, err := json.DecodeStringFloat32(d) s.RequiredStringFloat32 = v @@ -32443,7 +33038,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_float32\"") } case "required_string_float64": - requiredBitSet[18] |= 1 << 0 + requiredBitSet[18] |= 1 << 2 if err := func() error { v, err := json.DecodeStringFloat64(d) s.RequiredStringFloat64 = v @@ -32455,7 +33050,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_float64\"") } case "required_string_hostname": - requiredBitSet[18] |= 1 << 1 + requiredBitSet[18] |= 1 << 3 if err := func() error { v, err := d.Str() s.RequiredStringHostname = string(v) @@ -32467,7 +33062,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_hostname\"") } case "required_string_int": - requiredBitSet[18] |= 1 << 2 + requiredBitSet[18] |= 1 << 4 if err := func() error { v, err := json.DecodeStringInt(d) s.RequiredStringInt = v @@ -32479,7 +33074,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int\"") } case "required_string_int16": - requiredBitSet[18] |= 1 << 3 + requiredBitSet[18] |= 1 << 5 if err := func() error { v, err := json.DecodeStringInt16(d) s.RequiredStringInt16 = v @@ -32491,7 +33086,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int16\"") } case "required_string_int32": - requiredBitSet[18] |= 1 << 4 + requiredBitSet[18] |= 1 << 6 if err := func() error { v, err := json.DecodeStringInt32(d) s.RequiredStringInt32 = v @@ -32503,7 +33098,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int32\"") } case "required_string_int64": - requiredBitSet[18] |= 1 << 5 + requiredBitSet[18] |= 1 << 7 if err := func() error { v, err := json.DecodeStringInt64(d) s.RequiredStringInt64 = v @@ -32515,7 +33110,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int64\"") } case "required_string_int8": - requiredBitSet[18] |= 1 << 6 + requiredBitSet[19] |= 1 << 0 if err := func() error { v, err := json.DecodeStringInt8(d) s.RequiredStringInt8 = v @@ -32527,7 +33122,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_int8\"") } case "required_string_ip": - requiredBitSet[18] |= 1 << 7 + requiredBitSet[19] |= 1 << 1 if err := func() error { v, err := json.DecodeIP(d) s.RequiredStringIP = v @@ -32539,7 +33134,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ip\"") } case "required_string_ipv4": - requiredBitSet[19] |= 1 << 0 + requiredBitSet[19] |= 1 << 2 if err := func() error { v, err := json.DecodeIPv4(d) s.RequiredStringIpv4 = v @@ -32551,7 +33146,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_ipv4\"") } case "required_string_ipv6": - requiredBitSet[19] |= 1 << 1 + requiredBitSet[19] |= 1 << 3 if err := func() error { v, err := json.DecodeIPv6(d) s.RequiredStringIpv6 = v @@ -32562,8 +33157,20 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"required_string_ipv6\"") } + case "required_string_mac": + requiredBitSet[19] |= 1 << 4 + if err := func() error { + v, err := json.DecodeMAC(d) + s.RequiredStringMAC = v + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"required_string_mac\"") + } case "required_string_password": - requiredBitSet[19] |= 1 << 2 + requiredBitSet[19] |= 1 << 5 if err := func() error { v, err := d.Str() s.RequiredStringPassword = string(v) @@ -32575,7 +33182,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_password\"") } case "required_string_time": - requiredBitSet[19] |= 1 << 3 + requiredBitSet[19] |= 1 << 6 if err := func() error { v, err := json.DecodeTime(d) s.RequiredStringTime = v @@ -32587,7 +33194,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_time\"") } case "required_string_uint": - requiredBitSet[19] |= 1 << 4 + requiredBitSet[19] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUint(d) s.RequiredStringUint = v @@ -32599,7 +33206,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint\"") } case "required_string_uint16": - requiredBitSet[19] |= 1 << 5 + requiredBitSet[20] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUint16(d) s.RequiredStringUint16 = v @@ -32611,7 +33218,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint16\"") } case "required_string_uint32": - requiredBitSet[19] |= 1 << 6 + requiredBitSet[20] |= 1 << 1 if err := func() error { v, err := json.DecodeStringUint32(d) s.RequiredStringUint32 = v @@ -32623,7 +33230,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint32\"") } case "required_string_uint64": - requiredBitSet[19] |= 1 << 7 + requiredBitSet[20] |= 1 << 2 if err := func() error { v, err := json.DecodeStringUint64(d) s.RequiredStringUint64 = v @@ -32635,7 +33242,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint64\"") } case "required_string_uint8": - requiredBitSet[20] |= 1 << 0 + requiredBitSet[20] |= 1 << 3 if err := func() error { v, err := json.DecodeStringUint8(d) s.RequiredStringUint8 = v @@ -32647,7 +33254,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uint8\"") } case "required_string_unix": - requiredBitSet[20] |= 1 << 1 + requiredBitSet[20] |= 1 << 4 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnix = v @@ -32659,7 +33266,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix\"") } case "required_string_unix-micro": - requiredBitSet[20] |= 1 << 2 + requiredBitSet[20] |= 1 << 5 if err := func() error { v, err := json.DecodeStringUnixMicro(d) s.RequiredStringUnixMinusMicro = v @@ -32671,7 +33278,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[20] |= 1 << 3 + requiredBitSet[20] |= 1 << 6 if err := func() error { v, err := json.DecodeStringUnixMilli(d) s.RequiredStringUnixMinusMilli = v @@ -32683,7 +33290,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[20] |= 1 << 4 + requiredBitSet[20] |= 1 << 7 if err := func() error { v, err := json.DecodeStringUnixNano(d) s.RequiredStringUnixMinusNano = v @@ -32695,7 +33302,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[20] |= 1 << 5 + requiredBitSet[21] |= 1 << 0 if err := func() error { v, err := json.DecodeStringUnixSeconds(d) s.RequiredStringUnixMinusSeconds = v @@ -32707,7 +33314,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_unix-seconds\"") } case "required_string_uri": - requiredBitSet[20] |= 1 << 6 + requiredBitSet[21] |= 1 << 1 if err := func() error { v, err := json.DecodeURI(d) s.RequiredStringURI = v @@ -32719,7 +33326,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"required_string_uri\"") } case "required_string_uuid": - requiredBitSet[20] |= 1 << 7 + requiredBitSet[21] |= 1 << 2 if err := func() error { v, err := json.DecodeUUID(d) s.RequiredStringUUID = v @@ -33537,6 +34144,25 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_array_string_ipv6\"") } + case "optional_array_string_mac": + if err := func() error { + s.OptionalArrayStringMAC = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { + return err + } + s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_array_string_mac\"") + } case "optional_array_string_password": if err := func() error { s.OptionalArrayStringPassword = make([]string, 0) @@ -34945,6 +35571,33 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_double_array_string_ipv6\"") } + case "optional_double_array_string_mac": + if err := func() error { + s.OptionalDoubleArrayStringMAC = make([][]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + s.OptionalDoubleArrayStringMAC = append(s.OptionalDoubleArrayStringMAC, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_double_array_string_mac\"") + } case "optional_double_array_string_password": if err := func() error { s.OptionalDoubleArrayStringPassword = make([][]string, 0) @@ -35725,6 +36378,16 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"optional_string_ipv6\"") } + case "optional_string_mac": + if err := func() error { + s.OptionalStringMAC.Reset() + if err := s.OptionalStringMAC.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"optional_string_mac\"") + } case "optional_string_password": if err := func() error { s.OptionalStringPassword.Reset() @@ -35874,7 +36537,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [42]uint8{ + for i, mask := range [43]uint8{ 0b11111111, 0b11111111, 0b11111111, @@ -35896,6 +36559,7 @@ func (s *TestResponseFormatTestOK) Decode(d *jx.Decoder) error { 0b11111111, 0b11111111, 0b11111111, + 0b00000111, 0b00000000, 0b00000000, 0b00000000, diff --git a/examples/ex_test_format/oas_parameters_gen.go b/examples/ex_test_format/oas_parameters_gen.go index 3a0b3550a..8e791999d 100644 --- a/examples/ex_test_format/oas_parameters_gen.go +++ b/examples/ex_test_format/oas_parameters_gen.go @@ -4,6 +4,7 @@ package api import ( "fmt" + "net" "net/http" "net/netip" "net/url" @@ -101,6 +102,8 @@ type TestQueryParameterParams struct { StringIpv4Array []netip.Addr StringIpv6 netip.Addr StringIpv6Array []netip.Addr + StringMAC net.HardwareAddr + StringMACArray []net.HardwareAddr StringPassword string StringPasswordArray []string StringTime time.Time @@ -692,6 +695,20 @@ func unpackTestQueryParameterParams(packed middleware.Parameters) (params TestQu } params.StringIpv6Array = packed[key].([]netip.Addr) } + { + key := middleware.ParameterKey{ + Name: "string_mac", + In: "query", + } + params.StringMAC = packed[key].(net.HardwareAddr) + } + { + key := middleware.ParameterKey{ + Name: "string_mac_array", + In: "query", + } + params.StringMACArray = packed[key].([]net.HardwareAddr) + } { key := middleware.ParameterKey{ Name: "string_password", @@ -4660,6 +4677,95 @@ func decodeTestQueryParameterParams(args [0]string, argsEscaped bool, r *http.Re Err: err, } } + // Decode query: string_mac. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "string_mac", + 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.ToHardwareAddr(val) + if err != nil { + return err + } + + params.StringMAC = c + return nil + }); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "string_mac", + In: "query", + Err: err, + } + } + // Decode query: string_mac_array. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "string_mac_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 paramsDotStringMACArrayVal net.HardwareAddr + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToHardwareAddr(val) + if err != nil { + return err + } + + paramsDotStringMACArrayVal = c + return nil + }(); err != nil { + return err + } + params.StringMACArray = append(params.StringMACArray, paramsDotStringMACArrayVal) + return nil + }) + }); err != nil { + return err + } + if err := func() error { + if params.StringMACArray == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "string_mac_array", + In: "query", + Err: err, + } + } // Decode query: string_password. if err := func() error { 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 81df8acfd..8c514119f 100644 --- a/examples/ex_test_format/oas_request_decoders_gen.go +++ b/examples/ex_test_format/oas_request_decoders_gen.go @@ -6,6 +6,7 @@ import ( "fmt" "io" "mime" + "net" "net/http" "net/netip" "net/url" @@ -32743,8 +32744,8 @@ func (s *Server) decodeTestRequestRequiredStringIpv6NullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request) ( - req NilString, +func (s *Server) decodeTestRequestRequiredStringMACRequest(r *http.Request) ( + req net.HardwareAddr, close func() error, rerr error, ) { @@ -32783,9 +32784,11 @@ func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request NilString + var request net.HardwareAddr if err := func() error { - if err := request.Decode(d); err != nil { + v, err := json.DecodeMAC(d) + request = v + if err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -32806,8 +32809,8 @@ func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request) } } -func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Request) ( - req []NilString, +func (s *Server) decodeTestRequestRequiredStringMACArrayRequest(r *http.Request) ( + req []net.HardwareAddr, close func() error, rerr error, ) { @@ -32846,12 +32849,14 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) - var request []NilString + var request []net.HardwareAddr if err := func() error { - request = make([]NilString, 0) + request = make([]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -32885,8 +32890,8 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *http.Request) ( - req [][]NilString, +func (s *Server) decodeTestRequestRequiredStringMACArrayArrayRequest(r *http.Request) ( + req [][]net.HardwareAddr, close func() error, rerr error, ) { @@ -32925,15 +32930,17 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) - var request [][]NilString + var request [][]net.HardwareAddr if err := func() error { - request = make([][]NilString, 0) + request = make([][]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -32989,8 +32996,8 @@ func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request) ( - req string, +func (s *Server) decodeTestRequestRequiredStringMACNullableRequest(r *http.Request) ( + req NilHardwareAddr, close func() error, rerr error, ) { @@ -33029,11 +33036,9 @@ func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request string + var request NilHardwareAddr if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + if err := request.Decode(d); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -33054,8 +33059,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request) } } -func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Request) ( - req []string, +func (s *Server) decodeTestRequestRequiredStringMACNullableArrayRequest(r *http.Request) ( + req []NilHardwareAddr, close func() error, rerr error, ) { @@ -33094,14 +33099,12 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Req d := jx.DecodeBytes(buf) - var request []string + var request []NilHardwareAddr if err := func() error { - request = make([]string, 0) + request = make([]NilHardwareAddr, 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 NilHardwareAddr + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -33135,8 +33138,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *http.Request) ( - req [][]string, +func (s *Server) decodeTestRequestRequiredStringMACNullableArrayArrayRequest(r *http.Request) ( + req [][]NilHardwareAddr, close func() error, rerr error, ) { @@ -33175,17 +33178,15 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) - var request [][]string + var request [][]NilHardwareAddr if err := func() error { - request = make([][]string, 0) + request = make([][]NilHardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []NilHardwareAddr + elem = make([]NilHardwareAddr, 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 NilHardwareAddr + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -33241,7 +33242,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestRequiredStringPasswordNullableRequest(r *http.Request) ( +func (s *Server) decodeTestRequestRequiredStringNullableRequest(r *http.Request) ( req NilString, close func() error, rerr error, @@ -33304,7 +33305,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestRequestRequiredStringNullableArrayRequest(r *http.Request) ( req []NilString, close func() error, rerr error, @@ -33383,7 +33384,7 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestRequestRequiredStringNullableArrayArrayRequest(r *http.Request) ( req [][]NilString, close func() error, rerr error, @@ -33487,8 +33488,8 @@ func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayReques } } -func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request) ( - req time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordRequest(r *http.Request) ( + req string, close func() error, rerr error, ) { @@ -33527,10 +33528,10 @@ func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request time.Time + var request string if err := func() error { - v, err := json.DecodeTime(d) - request = v + v, err := d.Str() + request = string(v) if err != nil { return err } @@ -33552,8 +33553,195 @@ func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request) ( - req []time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordArrayRequest(r *http.Request) ( + 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 + } + 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) + + var request []string + if err := func() error { + request = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + 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) decodeTestRequestRequiredStringPasswordArrayArrayRequest(r *http.Request) ( + 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 + } + 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) + + var request [][]string + if err := func() error { + request = make([][]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []string + elem = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem string + v, err := d.Str() + elemElem = string(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 + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + 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) decodeTestRequestRequiredStringPasswordNullableRequest(r *http.Request) ( + req NilString, close func() error, rerr error, ) { @@ -33592,14 +33780,75 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request d := jx.DecodeBytes(buf) - var request []time.Time + var request NilString if err := func() error { - request = make([]time.Time, 0) + if err := request.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayRequest(r *http.Request) ( + req []NilString, + 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 + } + 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) + + var request []NilString + if err := func() error { + request = make([]NilString, 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 NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -33633,8 +33882,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Request) ( - req [][]time.Time, +func (s *Server) decodeTestRequestRequiredStringPasswordNullableArrayArrayRequest(r *http.Request) ( + req [][]NilString, close func() error, rerr error, ) { @@ -33673,17 +33922,15 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request [][]time.Time + var request [][]NilString 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.DecodeTime(d) - elemElem = v - if err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -33739,8 +33986,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Request) ( - req NilTime, +func (s *Server) decodeTestRequestRequiredStringTimeRequest(r *http.Request) ( + req time.Time, close func() error, rerr error, ) { @@ -33779,9 +34026,11 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Requ d := jx.DecodeBytes(buf) - var request NilTime + var request time.Time if err := func() error { - if err := request.Decode(d, json.DecodeTime); err != nil { + v, err := json.DecodeTime(d) + request = v + if err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -33802,8 +34051,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Requ } } -func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http.Request) ( - req []NilTime, +func (s *Server) decodeTestRequestRequiredStringTimeArrayRequest(r *http.Request) ( + req []time.Time, close func() error, rerr error, ) { @@ -33842,12 +34091,14 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http d := jx.DecodeBytes(buf) - var request []NilTime + var request []time.Time if err := func() error { - request = make([]NilTime, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilTime - if err := elem.Decode(d, json.DecodeTime); err != nil { + var elem time.Time + v, err := json.DecodeTime(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -33881,8 +34132,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http } } -func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r *http.Request) ( - req [][]NilTime, +func (s *Server) decodeTestRequestRequiredStringTimeArrayArrayRequest(r *http.Request) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -33921,15 +34172,17 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r d := jx.DecodeBytes(buf) - var request [][]NilTime + var request [][]time.Time if err := func() error { - request = make([][]NilTime, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilTime - elem = make([]NilTime, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilTime - if err := elemElem.Decode(d, json.DecodeTime); err != nil { + var elemElem time.Time + v, err := json.DecodeTime(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -33985,8 +34238,8 @@ func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r } } -func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request) ( - req url.URL, +func (s *Server) decodeTestRequestRequiredStringTimeNullableRequest(r *http.Request) ( + req NilTime, close func() error, rerr error, ) { @@ -34025,11 +34278,9 @@ func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request url.URL + var request NilTime if err := func() error { - v, err := json.DecodeURI(d) - request = v - if err != nil { + if err := request.Decode(d, json.DecodeTime); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -34050,8 +34301,8 @@ func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request) ( - req []url.URL, +func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayRequest(r *http.Request) ( + req []NilTime, close func() error, rerr error, ) { @@ -34090,14 +34341,12 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request []url.URL + var request []NilTime if err := func() error { - request = make([]url.URL, 0) + request = make([]NilTime, 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 NilTime + if err := elem.Decode(d, json.DecodeTime); err != nil { return err } request = append(request, elem) @@ -34131,8 +34380,8 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request) } } -func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Request) ( - req [][]url.URL, +func (s *Server) decodeTestRequestRequiredStringTimeNullableArrayArrayRequest(r *http.Request) ( + req [][]NilTime, close func() error, rerr error, ) { @@ -34171,17 +34420,15 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Req d := jx.DecodeBytes(buf) - var request [][]url.URL + var request [][]NilTime if err := func() error { - request = make([][]url.URL, 0) + request = make([][]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []url.URL - elem = make([]url.URL, 0) + var elem []NilTime + elem = make([]NilTime, 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 NilTime + if err := elemElem.Decode(d, json.DecodeTime); err != nil { return err } elem = append(elem, elemElem) @@ -34237,8 +34484,8 @@ func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Request) ( - req NilURI, +func (s *Server) decodeTestRequestRequiredStringURIRequest(r *http.Request) ( + req url.URL, close func() error, rerr error, ) { @@ -34277,9 +34524,11 @@ func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Reque d := jx.DecodeBytes(buf) - var request NilURI + var request url.URL if err := func() error { - if err := request.Decode(d); err != nil { + v, err := json.DecodeURI(d) + request = v + if err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -34300,8 +34549,8 @@ func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Reque } } -func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http.Request) ( - req []NilURI, +func (s *Server) decodeTestRequestRequiredStringURIArrayRequest(r *http.Request) ( + req []url.URL, close func() error, rerr error, ) { @@ -34340,12 +34589,14 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http. d := jx.DecodeBytes(buf) - var request []NilURI + var request []url.URL if err := func() error { - request = make([]NilURI, 0) + request = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilURI - if err := elem.Decode(d); err != nil { + var elem url.URL + v, err := json.DecodeURI(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -34379,8 +34630,8 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http. } } -func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r *http.Request) ( - req [][]NilURI, +func (s *Server) decodeTestRequestRequiredStringURIArrayArrayRequest(r *http.Request) ( + req [][]url.URL, close func() error, rerr error, ) { @@ -34419,15 +34670,17 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r * d := jx.DecodeBytes(buf) - var request [][]NilURI + var request [][]url.URL if err := func() error { - request = make([][]NilURI, 0) + request = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilURI - elem = make([]NilURI, 0) + var elem []url.URL + elem = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilURI - if err := elemElem.Decode(d); err != nil { + var elemElem url.URL + v, err := json.DecodeURI(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -34483,8 +34736,8 @@ func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r * } } -func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request) ( - req uuid.UUID, +func (s *Server) decodeTestRequestRequiredStringURINullableRequest(r *http.Request) ( + req NilURI, close func() error, rerr error, ) { @@ -34523,11 +34776,9 @@ func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request uuid.UUID + var request NilURI if err := func() error { - v, err := json.DecodeUUID(d) - request = v - if err != nil { + if err := request.Decode(d); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -34548,8 +34799,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request) ( - req []uuid.UUID, +func (s *Server) decodeTestRequestRequiredStringURINullableArrayRequest(r *http.Request) ( + req []NilURI, close func() error, rerr error, ) { @@ -34588,14 +34839,12 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request d := jx.DecodeBytes(buf) - var request []uuid.UUID + var request []NilURI if err := func() error { - request = make([]uuid.UUID, 0) + request = make([]NilURI, 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 NilURI + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -34629,8 +34878,8 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Request) ( - req [][]uuid.UUID, +func (s *Server) decodeTestRequestRequiredStringURINullableArrayArrayRequest(r *http.Request) ( + req [][]NilURI, close func() error, rerr error, ) { @@ -34669,17 +34918,267 @@ func (s *Server) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request [][]uuid.UUID + var request [][]NilURI if err := func() error { - request = make([][]uuid.UUID, 0) + request = make([][]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uuid.UUID - elem = make([]uuid.UUID, 0) + var elem []NilURI + elem = make([]NilURI, 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 NilURI + 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 + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + 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) decodeTestRequestRequiredStringUUIDRequest(r *http.Request) ( + req uuid.UUID, + 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 + } + 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) + + var request uuid.UUID + if err := func() error { + v, err := json.DecodeUUID(d) + request = v + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestRequiredStringUUIDArrayRequest(r *http.Request) ( + req []uuid.UUID, + 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 + } + 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) + + var request []uuid.UUID + if err := func() error { + request = make([]uuid.UUID, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem uuid.UUID + v, err := json.DecodeUUID(d) + elem = v + if err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + 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) decodeTestRequestRequiredStringUUIDArrayArrayRequest(r *http.Request) ( + req [][]uuid.UUID, + 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 + } + 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) + + var request [][]uuid.UUID + if err := func() error { + request = make([][]uuid.UUID, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []uuid.UUID + elem = make([]uuid.UUID, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem uuid.UUID + v, err := json.DecodeUUID(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -49696,8 +50195,8 @@ func (s *Server) decodeTestRequestStringIpv6NullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request) ( - req OptNilString, +func (s *Server) decodeTestRequestStringMACRequest(r *http.Request) ( + req OptHardwareAddr, close func() error, rerr error, ) { @@ -49739,7 +50238,7 @@ func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilString + var request OptHardwareAddr if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -49763,8 +50262,8 @@ func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request) ( - req []NilString, +func (s *Server) decodeTestRequestStringMACArrayRequest(r *http.Request) ( + req []net.HardwareAddr, close func() error, rerr error, ) { @@ -49806,12 +50305,14 @@ func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []NilString + var request []net.HardwareAddr if err := func() error { - request = make([]NilString, 0) + request = make([]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilString - if err := elem.Decode(d); err != nil { + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -49837,8 +50338,8 @@ func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Request) ( - req [][]NilString, +func (s *Server) decodeTestRequestStringMACArrayArrayRequest(r *http.Request) ( + req [][]net.HardwareAddr, close func() error, rerr error, ) { @@ -49880,15 +50381,17 @@ func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) - var request [][]NilString + var request [][]net.HardwareAddr if err := func() error { - request = make([][]NilString, 0) + request = make([][]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilString - elem = make([]NilString, 0) + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilString - if err := elemElem.Decode(d); err != nil { + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -49941,8 +50444,8 @@ func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request) ( - req OptString, +func (s *Server) decodeTestRequestStringMACNullableRequest(r *http.Request) ( + req OptNilHardwareAddr, close func() error, rerr error, ) { @@ -49984,7 +50487,7 @@ func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptString + var request OptNilHardwareAddr if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -50008,8 +50511,8 @@ func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request) ( - req []string, +func (s *Server) decodeTestRequestStringMACNullableArrayRequest(r *http.Request) ( + req []NilHardwareAddr, close func() error, rerr error, ) { @@ -50051,14 +50554,12 @@ func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []string + var request []NilHardwareAddr if err := func() error { - request = make([]string, 0) + request = make([]NilHardwareAddr, 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 NilHardwareAddr + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -50084,8 +50585,8 @@ func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Request) ( - req [][]string, +func (s *Server) decodeTestRequestStringMACNullableArrayArrayRequest(r *http.Request) ( + req [][]NilHardwareAddr, close func() error, rerr error, ) { @@ -50127,17 +50628,15 @@ func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) - var request [][]string + var request [][]NilHardwareAddr if err := func() error { - request = make([][]string, 0) + request = make([][]NilHardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []string - elem = make([]string, 0) + var elem []NilHardwareAddr + elem = make([]NilHardwareAddr, 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 NilHardwareAddr + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -50190,7 +50689,7 @@ func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringPasswordNullableRequest(r *http.Request) ( +func (s *Server) decodeTestRequestStringNullableRequest(r *http.Request) ( req OptNilString, close func() error, rerr error, @@ -50257,7 +50756,7 @@ func (s *Server) decodeTestRequestStringPasswordNullableRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestRequestStringNullableArrayRequest(r *http.Request) ( req []NilString, close func() error, rerr error, @@ -50331,7 +50830,7 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestRequestStringNullableArrayArrayRequest(r *http.Request) ( req [][]NilString, close func() error, rerr error, @@ -50435,8 +50934,8 @@ func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request) ( - req OptTime, +func (s *Server) decodeTestRequestStringPasswordRequest(r *http.Request) ( + req OptString, close func() error, rerr error, ) { @@ -50478,10 +50977,10 @@ func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptTime + var request OptString if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeTime); err != nil { + if err := request.Decode(d); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -50502,8 +51001,8 @@ func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request) ( - req []time.Time, +func (s *Server) decodeTestRequestStringPasswordArrayRequest(r *http.Request) ( + req []string, close func() error, rerr error, ) { @@ -50545,13 +51044,13 @@ func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []time.Time + var request []string 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.DecodeTime(d) - elem = v + var elem string + v, err := d.Str() + elem = string(v) if err != nil { return err } @@ -50578,8 +51077,8 @@ func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringPasswordArrayArrayRequest(r *http.Request) ( + req [][]string, close func() error, rerr error, ) { @@ -50621,16 +51120,16 @@ func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request [][]time.Time + var request [][]string 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.DecodeTime(d) - elemElem = v + var elemElem string + v, err := d.Str() + elemElem = string(v) if err != nil { return err } @@ -50684,8 +51183,8 @@ func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request) ( - req OptNilTime, +func (s *Server) decodeTestRequestStringPasswordNullableRequest(r *http.Request) ( + req OptNilString, close func() error, rerr error, ) { @@ -50727,10 +51226,10 @@ func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilTime + var request OptNilString if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeTime); err != nil { + if err := request.Decode(d); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -50751,8 +51250,8 @@ func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request) ( - req []NilTime, +func (s *Server) decodeTestRequestStringPasswordNullableArrayRequest(r *http.Request) ( + req []NilString, close func() error, rerr error, ) { @@ -50794,12 +51293,12 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) - var request []NilTime + var request []NilString if err := func() error { - request = make([]NilTime, 0) + request = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilTime - if err := elem.Decode(d, json.DecodeTime); err != nil { + var elem NilString + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -50825,8 +51324,8 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Request) ( - req [][]NilTime, +func (s *Server) decodeTestRequestStringPasswordNullableArrayArrayRequest(r *http.Request) ( + req [][]NilString, close func() error, rerr error, ) { @@ -50868,15 +51367,15 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request [][]NilTime + var request [][]NilString if err := func() error { - request = make([][]NilTime, 0) + request = make([][]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilTime - elem = make([]NilTime, 0) + var elem []NilString + elem = make([]NilString, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilTime - if err := elemElem.Decode(d, json.DecodeTime); err != nil { + var elemElem NilString + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -50929,8 +51428,8 @@ func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringURIRequest(r *http.Request) ( - req OptURI, +func (s *Server) decodeTestRequestStringTimeRequest(r *http.Request) ( + req OptTime, close func() error, rerr error, ) { @@ -50972,10 +51471,10 @@ func (s *Server) decodeTestRequestStringURIRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptURI + var request OptTime if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeTime); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -50996,8 +51495,8 @@ func (s *Server) decodeTestRequestStringURIRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request) ( - req []url.URL, +func (s *Server) decodeTestRequestStringTimeArrayRequest(r *http.Request) ( + req []time.Time, close func() error, rerr error, ) { @@ -51039,12 +51538,12 @@ func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []url.URL + var request []time.Time if err := func() error { - request = make([]url.URL, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem url.URL - v, err := json.DecodeURI(d) + var elem time.Time + v, err := json.DecodeTime(d) elem = v if err != nil { return err @@ -51072,8 +51571,8 @@ func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request) ( - req [][]url.URL, +func (s *Server) decodeTestRequestStringTimeArrayArrayRequest(r *http.Request) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -51115,15 +51614,15 @@ func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request [][]url.URL + var request [][]time.Time if err := func() error { - request = make([][]url.URL, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []url.URL - elem = make([]url.URL, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem url.URL - v, err := json.DecodeURI(d) + var elemElem time.Time + v, err := json.DecodeTime(d) elemElem = v if err != nil { return err @@ -51178,8 +51677,8 @@ func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request) ( - req OptNilURI, +func (s *Server) decodeTestRequestStringTimeNullableRequest(r *http.Request) ( + req OptNilTime, close func() error, rerr error, ) { @@ -51221,10 +51720,10 @@ func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilURI + var request OptNilTime if err := func() error { request.Reset() - if err := request.Decode(d); err != nil { + if err := request.Decode(d, json.DecodeTime); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -51245,8 +51744,8 @@ func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request) ( - req []NilURI, +func (s *Server) decodeTestRequestStringTimeNullableArrayRequest(r *http.Request) ( + req []NilTime, close func() error, rerr error, ) { @@ -51288,12 +51787,12 @@ func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request []NilURI + var request []NilTime if err := func() error { - request = make([]NilURI, 0) + request = make([]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilURI - if err := elem.Decode(d); err != nil { + var elem NilTime + if err := elem.Decode(d, json.DecodeTime); err != nil { return err } request = append(request, elem) @@ -51319,8 +51818,8 @@ func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Request) ( - req [][]NilURI, +func (s *Server) decodeTestRequestStringTimeNullableArrayArrayRequest(r *http.Request) ( + req [][]NilTime, close func() error, rerr error, ) { @@ -51362,15 +51861,15 @@ func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Req d := jx.DecodeBytes(buf) - var request [][]NilURI + var request [][]NilTime if err := func() error { - request = make([][]NilURI, 0) + request = make([][]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilURI - elem = make([]NilURI, 0) + var elem []NilTime + elem = make([]NilTime, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilURI - if err := elemElem.Decode(d); err != nil { + var elemElem NilTime + if err := elemElem.Decode(d, json.DecodeTime); err != nil { return err } elem = append(elem, elemElem) @@ -51423,8 +51922,8 @@ func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request) ( - req OptUUID, +func (s *Server) decodeTestRequestStringURIRequest(r *http.Request) ( + req OptURI, close func() error, rerr error, ) { @@ -51466,7 +51965,7 @@ func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptUUID + var request OptURI if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -51490,8 +51989,8 @@ func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request) ( - req []uuid.UUID, +func (s *Server) decodeTestRequestStringURIArrayRequest(r *http.Request) ( + req []url.URL, close func() error, rerr error, ) { @@ -51533,12 +52032,12 @@ func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []uuid.UUID + var request []url.URL if err := func() error { - request = make([]uuid.UUID, 0) + request = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uuid.UUID - v, err := json.DecodeUUID(d) + var elem url.URL + v, err := json.DecodeURI(d) elem = v if err != nil { return err @@ -51566,8 +52065,8 @@ func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request) ( - req [][]uuid.UUID, +func (s *Server) decodeTestRequestStringURIArrayArrayRequest(r *http.Request) ( + req [][]url.URL, close func() error, rerr error, ) { @@ -51609,15 +52108,15 @@ func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request [][]uuid.UUID + var request [][]url.URL if err := func() error { - request = make([][]uuid.UUID, 0) + request = make([][]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uuid.UUID - elem = make([]uuid.UUID, 0) + var elem []url.URL + elem = make([]url.URL, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uuid.UUID - v, err := json.DecodeUUID(d) + var elemElem url.URL + v, err := json.DecodeURI(d) elemElem = v if err != nil { return err @@ -51672,8 +52171,8 @@ func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request) ( - req OptNilUUID, +func (s *Server) decodeTestRequestStringURINullableRequest(r *http.Request) ( + req OptNilURI, close func() error, rerr error, ) { @@ -51715,7 +52214,7 @@ func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilUUID + var request OptNilURI if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -51739,8 +52238,8 @@ func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request) ( - req []NilUUID, +func (s *Server) decodeTestRequestStringURINullableArrayRequest(r *http.Request) ( + req []NilURI, close func() error, rerr error, ) { @@ -51782,11 +52281,11 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) - var request []NilUUID + var request []NilURI if err := func() error { - request = make([]NilUUID, 0) + request = make([]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilUUID + var elem NilURI if err := elem.Decode(d); err != nil { return err } @@ -51813,8 +52312,8 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Request) ( - req [][]NilUUID, +func (s *Server) decodeTestRequestStringURINullableArrayArrayRequest(r *http.Request) ( + req [][]NilURI, close func() error, rerr error, ) { @@ -51856,14 +52355,14 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request [][]NilUUID + var request [][]NilURI if err := func() error { - request = make([][]NilUUID, 0) + request = make([][]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilUUID - elem = make([]NilUUID, 0) + var elem []NilURI + elem = make([]NilURI, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilUUID + var elemElem NilURI if err := elemElem.Decode(d); err != nil { return err } @@ -51917,75 +52416,8 @@ func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUintRequest(r *http.Request) ( - req OptStringUint, - 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 - } - 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) - - var request OptStringUint - if err := func() error { - request.Reset() - if err := request.Decode(d); err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return req, close, err - } - return request, close, nil - default: - return req, close, validate.InvalidContentType(ct) - } -} - -func (s *Server) decodeTestRequestStringUint16Request(r *http.Request) ( - req OptStringUint16, +func (s *Server) decodeTestRequestStringUUIDRequest(r *http.Request) ( + req OptUUID, close func() error, rerr error, ) { @@ -52027,7 +52459,7 @@ func (s *Server) decodeTestRequestStringUint16Request(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUint16 + var request OptUUID if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -52051,8 +52483,8 @@ func (s *Server) decodeTestRequestStringUint16Request(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint16ArrayRequest(r *http.Request) ( - req []uint16, +func (s *Server) decodeTestRequestStringUUIDArrayRequest(r *http.Request) ( + req []uuid.UUID, close func() error, rerr error, ) { @@ -52094,12 +52526,12 @@ func (s *Server) decodeTestRequestStringUint16ArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []uint16 + var request []uuid.UUID if err := func() error { - request = make([]uint16, 0) + request = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uint16 - v, err := json.DecodeStringUint16(d) + var elem uuid.UUID + v, err := json.DecodeUUID(d) elem = v if err != nil { return err @@ -52127,8 +52559,8 @@ func (s *Server) decodeTestRequestStringUint16ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint16ArrayArrayRequest(r *http.Request) ( - req [][]uint16, +func (s *Server) decodeTestRequestStringUUIDArrayArrayRequest(r *http.Request) ( + req [][]uuid.UUID, close func() error, rerr error, ) { @@ -52170,15 +52602,15 @@ func (s *Server) decodeTestRequestStringUint16ArrayArrayRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request [][]uint16 + var request [][]uuid.UUID if err := func() error { - request = make([][]uint16, 0) + request = make([][]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uint16 - elem = make([]uint16, 0) + var elem []uuid.UUID + elem = make([]uuid.UUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uint16 - v, err := json.DecodeStringUint16(d) + var elemElem uuid.UUID + v, err := json.DecodeUUID(d) elemElem = v if err != nil { return err @@ -52233,8 +52665,8 @@ func (s *Server) decodeTestRequestStringUint16ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringUint16NullableRequest(r *http.Request) ( - req OptNilStringUint16, +func (s *Server) decodeTestRequestStringUUIDNullableRequest(r *http.Request) ( + req OptNilUUID, close func() error, rerr error, ) { @@ -52276,7 +52708,7 @@ func (s *Server) decodeTestRequestStringUint16NullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilStringUint16 + var request OptNilUUID if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -52300,8 +52732,8 @@ func (s *Server) decodeTestRequestStringUint16NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint16NullableArrayRequest(r *http.Request) ( - req []NilStringUint16, +func (s *Server) decodeTestRequestStringUUIDNullableArrayRequest(r *http.Request) ( + req []NilUUID, close func() error, rerr error, ) { @@ -52343,11 +52775,11 @@ func (s *Server) decodeTestRequestStringUint16NullableArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) - var request []NilStringUint16 + var request []NilUUID if err := func() error { - request = make([]NilStringUint16, 0) + request = make([]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUint16 + var elem NilUUID if err := elem.Decode(d); err != nil { return err } @@ -52374,8 +52806,8 @@ func (s *Server) decodeTestRequestStringUint16NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUint16NullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUint16, +func (s *Server) decodeTestRequestStringUUIDNullableArrayArrayRequest(r *http.Request) ( + req [][]NilUUID, close func() error, rerr error, ) { @@ -52417,14 +52849,14 @@ func (s *Server) decodeTestRequestStringUint16NullableArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) - var request [][]NilStringUint16 + var request [][]NilUUID if err := func() error { - request = make([][]NilStringUint16, 0) + request = make([][]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUint16 - elem = make([]NilStringUint16, 0) + var elem []NilUUID + elem = make([]NilUUID, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUint16 + var elemElem NilUUID if err := elemElem.Decode(d); err != nil { return err } @@ -52478,8 +52910,8 @@ func (s *Server) decodeTestRequestStringUint16NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestStringUint32Request(r *http.Request) ( - req OptStringUint32, +func (s *Server) decodeTestRequestStringUintRequest(r *http.Request) ( + req OptStringUint, close func() error, rerr error, ) { @@ -52521,7 +52953,7 @@ func (s *Server) decodeTestRequestStringUint32Request(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUint32 + var request OptStringUint if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -52545,8 +52977,8 @@ func (s *Server) decodeTestRequestStringUint32Request(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint32ArrayRequest(r *http.Request) ( - req []uint32, +func (s *Server) decodeTestRequestStringUint16Request(r *http.Request) ( + req OptStringUint16, close func() error, rerr error, ) { @@ -52588,12 +53020,79 @@ func (s *Server) decodeTestRequestStringUint32ArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []uint32 + var request OptStringUint16 if err := func() error { - request = make([]uint32, 0) + request.Reset() + if err := request.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUint16ArrayRequest(r *http.Request) ( + req []uint16, + 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 + } + 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) + + var request []uint16 + if err := func() error { + request = make([]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uint32 - v, err := json.DecodeStringUint32(d) + var elem uint16 + v, err := json.DecodeStringUint16(d) elem = v if err != nil { return err @@ -52621,8 +53120,8 @@ func (s *Server) decodeTestRequestStringUint32ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint32ArrayArrayRequest(r *http.Request) ( - req [][]uint32, +func (s *Server) decodeTestRequestStringUint16ArrayArrayRequest(r *http.Request) ( + req [][]uint16, close func() error, rerr error, ) { @@ -52664,15 +53163,15 @@ func (s *Server) decodeTestRequestStringUint32ArrayArrayRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request [][]uint32 + var request [][]uint16 if err := func() error { - request = make([][]uint32, 0) + request = make([][]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uint32 - elem = make([]uint32, 0) + var elem []uint16 + elem = make([]uint16, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uint32 - v, err := json.DecodeStringUint32(d) + var elemElem uint16 + v, err := json.DecodeStringUint16(d) elemElem = v if err != nil { return err @@ -52727,8 +53226,8 @@ func (s *Server) decodeTestRequestStringUint32ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringUint32NullableRequest(r *http.Request) ( - req OptNilStringUint32, +func (s *Server) decodeTestRequestStringUint16NullableRequest(r *http.Request) ( + req OptNilStringUint16, close func() error, rerr error, ) { @@ -52770,7 +53269,7 @@ func (s *Server) decodeTestRequestStringUint32NullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilStringUint32 + var request OptNilStringUint16 if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -52794,8 +53293,8 @@ func (s *Server) decodeTestRequestStringUint32NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint32NullableArrayRequest(r *http.Request) ( - req []NilStringUint32, +func (s *Server) decodeTestRequestStringUint16NullableArrayRequest(r *http.Request) ( + req []NilStringUint16, close func() error, rerr error, ) { @@ -52837,11 +53336,11 @@ func (s *Server) decodeTestRequestStringUint32NullableArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) - var request []NilStringUint32 + var request []NilStringUint16 if err := func() error { - request = make([]NilStringUint32, 0) + request = make([]NilStringUint16, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUint32 + var elem NilStringUint16 if err := elem.Decode(d); err != nil { return err } @@ -52868,8 +53367,8 @@ func (s *Server) decodeTestRequestStringUint32NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUint32NullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUint32, +func (s *Server) decodeTestRequestStringUint16NullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUint16, close func() error, rerr error, ) { @@ -52911,14 +53410,14 @@ func (s *Server) decodeTestRequestStringUint32NullableArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) - var request [][]NilStringUint32 + var request [][]NilStringUint16 if err := func() error { - request = make([][]NilStringUint32, 0) + request = make([][]NilStringUint16, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUint32 - elem = make([]NilStringUint32, 0) + var elem []NilStringUint16 + elem = make([]NilStringUint16, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUint32 + var elemElem NilStringUint16 if err := elemElem.Decode(d); err != nil { return err } @@ -52972,8 +53471,8 @@ func (s *Server) decodeTestRequestStringUint32NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestStringUint64Request(r *http.Request) ( - req OptStringUint64, +func (s *Server) decodeTestRequestStringUint32Request(r *http.Request) ( + req OptStringUint32, close func() error, rerr error, ) { @@ -53015,7 +53514,7 @@ func (s *Server) decodeTestRequestStringUint64Request(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUint64 + var request OptStringUint32 if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -53039,8 +53538,8 @@ func (s *Server) decodeTestRequestStringUint64Request(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint64ArrayRequest(r *http.Request) ( - req []uint64, +func (s *Server) decodeTestRequestStringUint32ArrayRequest(r *http.Request) ( + req []uint32, close func() error, rerr error, ) { @@ -53082,12 +53581,12 @@ func (s *Server) decodeTestRequestStringUint64ArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []uint64 + var request []uint32 if err := func() error { - request = make([]uint64, 0) + request = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uint64 - v, err := json.DecodeStringUint64(d) + var elem uint32 + v, err := json.DecodeStringUint32(d) elem = v if err != nil { return err @@ -53115,8 +53614,8 @@ func (s *Server) decodeTestRequestStringUint64ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint64ArrayArrayRequest(r *http.Request) ( - req [][]uint64, +func (s *Server) decodeTestRequestStringUint32ArrayArrayRequest(r *http.Request) ( + req [][]uint32, close func() error, rerr error, ) { @@ -53158,15 +53657,15 @@ func (s *Server) decodeTestRequestStringUint64ArrayArrayRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request [][]uint64 + var request [][]uint32 if err := func() error { - request = make([][]uint64, 0) + request = make([][]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uint64 - elem = make([]uint64, 0) + var elem []uint32 + elem = make([]uint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uint64 - v, err := json.DecodeStringUint64(d) + var elemElem uint32 + v, err := json.DecodeStringUint32(d) elemElem = v if err != nil { return err @@ -53221,8 +53720,8 @@ func (s *Server) decodeTestRequestStringUint64ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringUint64NullableRequest(r *http.Request) ( - req OptNilStringUint64, +func (s *Server) decodeTestRequestStringUint32NullableRequest(r *http.Request) ( + req OptNilStringUint32, close func() error, rerr error, ) { @@ -53264,7 +53763,7 @@ func (s *Server) decodeTestRequestStringUint64NullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilStringUint64 + var request OptNilStringUint32 if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -53288,8 +53787,8 @@ func (s *Server) decodeTestRequestStringUint64NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint64NullableArrayRequest(r *http.Request) ( - req []NilStringUint64, +func (s *Server) decodeTestRequestStringUint32NullableArrayRequest(r *http.Request) ( + req []NilStringUint32, close func() error, rerr error, ) { @@ -53331,11 +53830,11 @@ func (s *Server) decodeTestRequestStringUint64NullableArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) - var request []NilStringUint64 + var request []NilStringUint32 if err := func() error { - request = make([]NilStringUint64, 0) + request = make([]NilStringUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUint64 + var elem NilStringUint32 if err := elem.Decode(d); err != nil { return err } @@ -53362,8 +53861,8 @@ func (s *Server) decodeTestRequestStringUint64NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUint64NullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUint64, +func (s *Server) decodeTestRequestStringUint32NullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUint32, close func() error, rerr error, ) { @@ -53405,14 +53904,14 @@ func (s *Server) decodeTestRequestStringUint64NullableArrayArrayRequest(r *http. d := jx.DecodeBytes(buf) - var request [][]NilStringUint64 + var request [][]NilStringUint32 if err := func() error { - request = make([][]NilStringUint64, 0) + request = make([][]NilStringUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUint64 - elem = make([]NilStringUint64, 0) + var elem []NilStringUint32 + elem = make([]NilStringUint32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUint64 + var elemElem NilStringUint32 if err := elemElem.Decode(d); err != nil { return err } @@ -53466,8 +53965,8 @@ func (s *Server) decodeTestRequestStringUint64NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestRequestStringUint8Request(r *http.Request) ( - req OptStringUint8, +func (s *Server) decodeTestRequestStringUint64Request(r *http.Request) ( + req OptStringUint64, close func() error, rerr error, ) { @@ -53509,7 +54008,7 @@ func (s *Server) decodeTestRequestStringUint8Request(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUint8 + var request OptStringUint64 if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -53533,8 +54032,8 @@ func (s *Server) decodeTestRequestStringUint8Request(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint8ArrayRequest(r *http.Request) ( - req []uint8, +func (s *Server) decodeTestRequestStringUint64ArrayRequest(r *http.Request) ( + req []uint64, close func() error, rerr error, ) { @@ -53576,12 +54075,12 @@ func (s *Server) decodeTestRequestStringUint8ArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []uint8 + var request []uint64 if err := func() error { - request = make([]uint8, 0) + request = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uint8 - v, err := json.DecodeStringUint8(d) + var elem uint64 + v, err := json.DecodeStringUint64(d) elem = v if err != nil { return err @@ -53609,8 +54108,8 @@ func (s *Server) decodeTestRequestStringUint8ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint8ArrayArrayRequest(r *http.Request) ( - req [][]uint8, +func (s *Server) decodeTestRequestStringUint64ArrayArrayRequest(r *http.Request) ( + req [][]uint64, close func() error, rerr error, ) { @@ -53652,15 +54151,15 @@ func (s *Server) decodeTestRequestStringUint8ArrayArrayRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request [][]uint8 + var request [][]uint64 if err := func() error { - request = make([][]uint8, 0) + request = make([][]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uint8 - elem = make([]uint8, 0) + var elem []uint64 + elem = make([]uint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uint8 - v, err := json.DecodeStringUint8(d) + var elemElem uint64 + v, err := json.DecodeStringUint64(d) elemElem = v if err != nil { return err @@ -53715,8 +54214,8 @@ func (s *Server) decodeTestRequestStringUint8ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringUint8NullableRequest(r *http.Request) ( - req OptNilStringUint8, +func (s *Server) decodeTestRequestStringUint64NullableRequest(r *http.Request) ( + req OptNilStringUint64, close func() error, rerr error, ) { @@ -53758,7 +54257,7 @@ func (s *Server) decodeTestRequestStringUint8NullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilStringUint8 + var request OptNilStringUint64 if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -53782,8 +54281,8 @@ func (s *Server) decodeTestRequestStringUint8NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUint8NullableArrayRequest(r *http.Request) ( - req []NilStringUint8, +func (s *Server) decodeTestRequestStringUint64NullableArrayRequest(r *http.Request) ( + req []NilStringUint64, close func() error, rerr error, ) { @@ -53825,11 +54324,11 @@ func (s *Server) decodeTestRequestStringUint8NullableArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) - var request []NilStringUint8 + var request []NilStringUint64 if err := func() error { - request = make([]NilStringUint8, 0) + request = make([]NilStringUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUint8 + var elem NilStringUint64 if err := elem.Decode(d); err != nil { return err } @@ -53856,8 +54355,8 @@ func (s *Server) decodeTestRequestStringUint8NullableArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringUint8NullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUint8, +func (s *Server) decodeTestRequestStringUint64NullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUint64, close func() error, rerr error, ) { @@ -53899,14 +54398,14 @@ func (s *Server) decodeTestRequestStringUint8NullableArrayArrayRequest(r *http.R d := jx.DecodeBytes(buf) - var request [][]NilStringUint8 + var request [][]NilStringUint64 if err := func() error { - request = make([][]NilStringUint8, 0) + request = make([][]NilStringUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUint8 - elem = make([]NilStringUint8, 0) + var elem []NilStringUint64 + elem = make([]NilStringUint64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUint8 + var elemElem NilStringUint64 if err := elemElem.Decode(d); err != nil { return err } @@ -53960,8 +54459,8 @@ func (s *Server) decodeTestRequestStringUint8NullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestRequestStringUintArrayRequest(r *http.Request) ( - req []uint, +func (s *Server) decodeTestRequestStringUint8Request(r *http.Request) ( + req OptStringUint8, close func() error, rerr error, ) { @@ -54003,12 +54502,79 @@ func (s *Server) decodeTestRequestStringUintArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []uint + var request OptStringUint8 if err := func() error { - request = make([]uint, 0) + request.Reset() + if err := request.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUint8ArrayRequest(r *http.Request) ( + req []uint8, + 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 + } + 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) + + var request []uint8 + if err := func() error { + request = make([]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem uint - v, err := json.DecodeStringUint(d) + var elem uint8 + v, err := json.DecodeStringUint8(d) elem = v if err != nil { return err @@ -54036,8 +54602,8 @@ func (s *Server) decodeTestRequestStringUintArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUintArrayArrayRequest(r *http.Request) ( - req [][]uint, +func (s *Server) decodeTestRequestStringUint8ArrayArrayRequest(r *http.Request) ( + req [][]uint8, close func() error, rerr error, ) { @@ -54079,15 +54645,15 @@ func (s *Server) decodeTestRequestStringUintArrayArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request [][]uint + var request [][]uint8 if err := func() error { - request = make([][]uint, 0) + request = make([][]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []uint - elem = make([]uint, 0) + var elem []uint8 + elem = make([]uint8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem uint - v, err := json.DecodeStringUint(d) + var elemElem uint8 + v, err := json.DecodeStringUint8(d) elemElem = v if err != nil { return err @@ -54142,8 +54708,8 @@ func (s *Server) decodeTestRequestStringUintArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUintNullableRequest(r *http.Request) ( - req OptNilStringUint, +func (s *Server) decodeTestRequestStringUint8NullableRequest(r *http.Request) ( + req OptNilStringUint8, close func() error, rerr error, ) { @@ -54185,7 +54751,7 @@ func (s *Server) decodeTestRequestStringUintNullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilStringUint + var request OptNilStringUint8 if err := func() error { request.Reset() if err := request.Decode(d); err != nil { @@ -54209,8 +54775,8 @@ func (s *Server) decodeTestRequestStringUintNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUintNullableArrayRequest(r *http.Request) ( - req []NilStringUint, +func (s *Server) decodeTestRequestStringUint8NullableArrayRequest(r *http.Request) ( + req []NilStringUint8, close func() error, rerr error, ) { @@ -54252,11 +54818,11 @@ func (s *Server) decodeTestRequestStringUintNullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) - var request []NilStringUint + var request []NilStringUint8 if err := func() error { - request = make([]NilStringUint, 0) + request = make([]NilStringUint8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUint + var elem NilStringUint8 if err := elem.Decode(d); err != nil { return err } @@ -54283,8 +54849,8 @@ func (s *Server) decodeTestRequestStringUintNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUintNullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUint, +func (s *Server) decodeTestRequestStringUint8NullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUint8, close func() error, rerr error, ) { @@ -54326,14 +54892,14 @@ func (s *Server) decodeTestRequestStringUintNullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request [][]NilStringUint + var request [][]NilStringUint8 if err := func() error { - request = make([][]NilStringUint, 0) + request = make([][]NilStringUint8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUint - elem = make([]NilStringUint, 0) + var elem []NilStringUint8 + elem = make([]NilStringUint8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUint + var elemElem NilStringUint8 if err := elemElem.Decode(d); err != nil { return err } @@ -54387,8 +54953,8 @@ func (s *Server) decodeTestRequestStringUintNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request) ( - req OptStringUnixSeconds, +func (s *Server) decodeTestRequestStringUintArrayRequest(r *http.Request) ( + req []uint, close func() error, rerr error, ) { @@ -54430,79 +54996,12 @@ func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUnixSeconds - if err := func() error { - request.Reset() - if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return req, close, err - } - return request, close, nil - default: - return req, close, validate.InvalidContentType(ct) - } -} - -func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request) ( - 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 - } - 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) - - var request []time.Time + var request []uint if err := func() error { - request = make([]time.Time, 0) + request = make([]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem time.Time - v, err := json.DecodeStringUnixSeconds(d) + var elem uint + v, err := json.DecodeStringUint(d) elem = v if err != nil { return err @@ -54530,8 +55029,8 @@ func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringUintArrayArrayRequest(r *http.Request) ( + req [][]uint, close func() error, rerr error, ) { @@ -54573,15 +55072,15 @@ func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request [][]time.Time + var request [][]uint if err := func() error { - request = make([][]time.Time, 0) + request = make([][]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []uint + elem = make([]uint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem time.Time - v, err := json.DecodeStringUnixSeconds(d) + var elemElem uint + v, err := json.DecodeStringUint(d) elemElem = v if err != nil { return err @@ -54636,8 +55135,8 @@ func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request) ( - req OptStringUnixMicro, +func (s *Server) decodeTestRequestStringUintNullableRequest(r *http.Request) ( + req OptNilStringUint, close func() error, rerr error, ) { @@ -54679,10 +55178,10 @@ func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUnixMicro + var request OptNilStringUint if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { + if err := request.Decode(d); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -54703,8 +55202,8 @@ func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request) ( - req []time.Time, +func (s *Server) decodeTestRequestStringUintNullableArrayRequest(r *http.Request) ( + req []NilStringUint, close func() error, rerr error, ) { @@ -54746,14 +55245,12 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []time.Time + var request []NilStringUint if err := func() error { - request = make([]time.Time, 0) + request = make([]NilStringUint, 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 NilStringUint + if err := elem.Decode(d); err != nil { return err } request = append(request, elem) @@ -54779,8 +55276,8 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Request) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringUintNullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUint, close func() error, rerr error, ) { @@ -54822,17 +55319,15 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Reque d := jx.DecodeBytes(buf) - var request [][]time.Time + var request [][]NilStringUint if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilStringUint, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilStringUint + elem = make([]NilStringUint, 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 NilStringUint + if err := elemElem.Decode(d); err != nil { return err } elem = append(elem, elemElem) @@ -54885,8 +55380,8 @@ func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request) ( - req OptNilStringUnixMicro, +func (s *Server) decodeTestRequestStringUnixRequest(r *http.Request) ( + req OptStringUnixSeconds, close func() error, rerr error, ) { @@ -54928,10 +55423,10 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request d := jx.DecodeBytes(buf) - var request OptNilStringUnixMicro + var request OptStringUnixSeconds if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { + if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -54952,8 +55447,8 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Request) ( - req []NilStringUnixMicro, +func (s *Server) decodeTestRequestStringUnixArrayRequest(r *http.Request) ( + req []time.Time, close func() error, rerr error, ) { @@ -54995,12 +55490,14 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request []NilStringUnixMicro + var request []time.Time 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.DecodeStringUnixSeconds(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -55026,8 +55523,8 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUnixMicro, +func (s *Server) decodeTestRequestStringUnixArrayArrayRequest(r *http.Request) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -55069,15 +55566,17 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) - var request [][]NilStringUnixMicro + var request [][]time.Time 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.DecodeStringUnixSeconds(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -55130,8 +55629,8 @@ func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request) ( - req OptStringUnixMilli, +func (s *Server) decodeTestRequestStringUnixMicroRequest(r *http.Request) ( + req OptStringUnixMicro, close func() error, rerr error, ) { @@ -55173,10 +55672,10 @@ func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUnixMilli + var request OptStringUnixMicro if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { + if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -55197,7 +55696,7 @@ func (s *Server) decodeTestRequestStringUnixMilliRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request) ( +func (s *Server) decodeTestRequestStringUnixMicroArrayRequest(r *http.Request) ( req []time.Time, close func() error, rerr error, @@ -55245,7 +55744,7 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request) ( request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem time.Time - v, err := json.DecodeStringUnixMilli(d) + v, err := json.DecodeStringUnixMicro(d) elem = v if err != nil { return err @@ -55273,7 +55772,7 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestRequestStringUnixMicroArrayArrayRequest(r *http.Request) ( req [][]time.Time, close func() error, rerr error, @@ -55324,7 +55823,7 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Reque elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { var elemElem time.Time - v, err := json.DecodeStringUnixMilli(d) + v, err := json.DecodeStringUnixMicro(d) elemElem = v if err != nil { return err @@ -55379,8 +55878,75 @@ func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request) ( - req OptNilStringUnixMilli, +func (s *Server) decodeTestRequestStringUnixMicroNullableRequest(r *http.Request) ( + req OptNilStringUnixMicro, + 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 + } + 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) + + var request OptNilStringUnixMicro + if err := func() error { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixMicro); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixMicroNullableArrayRequest(r *http.Request) ( + req []NilStringUnixMicro, close func() error, rerr error, ) { @@ -55422,7 +55988,185 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request d := jx.DecodeBytes(buf) - var request OptNilStringUnixMilli + var request []NilStringUnixMicro + if err := func() error { + request = make([]NilStringUnixMicro, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilStringUnixMicro + if err := elem.Decode(d, json.DecodeStringUnixMicro); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestRequestStringUnixMicroNullableArrayArrayRequest(r *http.Request) ( + 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()) + } + }() + 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 + } + 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) + + var request [][]NilStringUnixMicro + 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 NilStringUnixMicro + if err := elemElem.Decode(d, json.DecodeStringUnixMicro); err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + request = append(request, elem) + return nil + }); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + 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) decodeTestRequestStringUnixMilliRequest(r *http.Request) ( + req OptStringUnixMilli, + 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 + } + 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) + + var request OptStringUnixMilli if err := func() error { request.Reset() if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { @@ -55446,8 +56190,8 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Request) ( - req []NilStringUnixMilli, +func (s *Server) decodeTestRequestStringUnixMilliArrayRequest(r *http.Request) ( + req []time.Time, close func() error, rerr error, ) { @@ -55489,12 +56233,14 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request []NilStringUnixMilli + var request []time.Time if err := func() error { - request = make([]NilStringUnixMilli, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixMilli - if err := elem.Decode(d, json.DecodeStringUnixMilli); err != nil { + var elem time.Time + v, err := json.DecodeStringUnixMilli(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -55520,8 +56266,8 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUnixMilli, +func (s *Server) decodeTestRequestStringUnixMilliArrayArrayRequest(r *http.Request) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -55563,15 +56309,17 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *ht d := jx.DecodeBytes(buf) - var request [][]NilStringUnixMilli + var request [][]time.Time if err := func() error { - request = make([][]NilStringUnixMilli, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixMilli - elem = make([]NilStringUnixMilli, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixMilli - if err := elemElem.Decode(d, json.DecodeStringUnixMilli); err != nil { + var elemElem time.Time + v, err := json.DecodeStringUnixMilli(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -55624,8 +56372,8 @@ func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request) ( - req OptStringUnixNano, +func (s *Server) decodeTestRequestStringUnixMilliNullableRequest(r *http.Request) ( + req OptNilStringUnixMilli, close func() error, rerr error, ) { @@ -55667,10 +56415,10 @@ func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUnixNano + var request OptNilStringUnixMilli if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { + if err := request.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -55691,8 +56439,8 @@ func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request) ( - req []time.Time, +func (s *Server) decodeTestRequestStringUnixMilliNullableArrayRequest(r *http.Request) ( + req []NilStringUnixMilli, close func() error, rerr error, ) { @@ -55734,14 +56482,12 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request []time.Time + var request []NilStringUnixMilli if err := func() error { - request = make([]time.Time, 0) + request = make([]NilStringUnixMilli, 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 NilStringUnixMilli + if err := elem.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } request = append(request, elem) @@ -55767,8 +56513,8 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Request) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringUnixMilliNullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUnixMilli, close func() error, rerr error, ) { @@ -55810,17 +56556,15 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Reques d := jx.DecodeBytes(buf) - var request [][]time.Time + var request [][]NilStringUnixMilli if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilStringUnixMilli, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilStringUnixMilli + elem = make([]NilStringUnixMilli, 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 NilStringUnixMilli + if err := elemElem.Decode(d, json.DecodeStringUnixMilli); err != nil { return err } elem = append(elem, elemElem) @@ -55873,8 +56617,8 @@ func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request) ( - req OptNilStringUnixNano, +func (s *Server) decodeTestRequestStringUnixNanoRequest(r *http.Request) ( + req OptStringUnixNano, close func() error, rerr error, ) { @@ -55916,7 +56660,7 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request OptNilStringUnixNano + var request OptStringUnixNano if err := func() error { request.Reset() if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { @@ -55940,8 +56684,8 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Request) ( - req []NilStringUnixNano, +func (s *Server) decodeTestRequestStringUnixNanoArrayRequest(r *http.Request) ( + req []time.Time, close func() error, rerr error, ) { @@ -55983,12 +56727,14 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Req d := jx.DecodeBytes(buf) - var request []NilStringUnixNano + var request []time.Time if err := func() error { - request = make([]NilStringUnixNano, 0) + request = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixNano - if err := elem.Decode(d, json.DecodeStringUnixNano); err != nil { + var elem time.Time + v, err := json.DecodeStringUnixNano(d) + elem = v + if err != nil { return err } request = append(request, elem) @@ -56014,8 +56760,8 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUnixNano, +func (s *Server) decodeTestRequestStringUnixNanoArrayArrayRequest(r *http.Request) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -56057,15 +56803,17 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *htt d := jx.DecodeBytes(buf) - var request [][]NilStringUnixNano + var request [][]time.Time if err := func() error { - request = make([][]NilStringUnixNano, 0) + request = make([][]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixNano - elem = make([]NilStringUnixNano, 0) + var elem []time.Time + elem = make([]time.Time, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixNano - if err := elemElem.Decode(d, json.DecodeStringUnixNano); err != nil { + var elemElem time.Time + v, err := json.DecodeStringUnixNano(d) + elemElem = v + if err != nil { return err } elem = append(elem, elemElem) @@ -56118,8 +56866,8 @@ func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request) ( - req OptNilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixNanoNullableRequest(r *http.Request) ( + req OptNilStringUnixNano, close func() error, rerr error, ) { @@ -56161,10 +56909,10 @@ func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptNilStringUnixSeconds + var request OptNilStringUnixNano if err := func() error { request.Reset() - if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { + if err := request.Decode(d, json.DecodeStringUnixNano); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -56185,8 +56933,8 @@ func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request) ( - req []NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixNanoNullableArrayRequest(r *http.Request) ( + req []NilStringUnixNano, close func() error, rerr error, ) { @@ -56228,12 +56976,12 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request d := jx.DecodeBytes(buf) - var request []NilStringUnixSeconds + var request []NilStringUnixNano if err := func() error { - request = make([]NilStringUnixSeconds, 0) + request = make([]NilStringUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringUnixSeconds - if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elem NilStringUnixNano + if err := elem.Decode(d, json.DecodeStringUnixNano); err != nil { return err } request = append(request, elem) @@ -56259,8 +57007,8 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixNanoNullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUnixNano, close func() error, rerr error, ) { @@ -56302,15 +57050,15 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Re d := jx.DecodeBytes(buf) - var request [][]NilStringUnixSeconds + var request [][]NilStringUnixNano if err := func() error { - request = make([][]NilStringUnixSeconds, 0) + request = make([][]NilStringUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringUnixSeconds - elem = make([]NilStringUnixSeconds, 0) + var elem []NilStringUnixNano + elem = make([]NilStringUnixNano, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringUnixSeconds - if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { + var elemElem NilStringUnixNano + if err := elemElem.Decode(d, json.DecodeStringUnixNano); err != nil { return err } elem = append(elem, elemElem) @@ -56363,8 +57111,8 @@ func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request) ( - req OptStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixNullableRequest(r *http.Request) ( + req OptNilStringUnixSeconds, close func() error, rerr error, ) { @@ -56406,7 +57154,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request) ( d := jx.DecodeBytes(buf) - var request OptStringUnixSeconds + var request OptNilStringUnixSeconds if err := func() error { request.Reset() if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { @@ -56430,8 +57178,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request) ( } } -func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request) ( - req []time.Time, +func (s *Server) decodeTestRequestStringUnixNullableArrayRequest(r *http.Request) ( + req []NilStringUnixSeconds, close func() error, rerr error, ) { @@ -56473,14 +57221,12 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request) d := jx.DecodeBytes(buf) - var request []time.Time + var request []NilStringUnixSeconds if err := func() error { - request = make([]time.Time, 0) + request = make([]NilStringUnixSeconds, 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 NilStringUnixSeconds + if err := elem.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } request = append(request, elem) @@ -56506,8 +57252,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request) } } -func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Request) ( - req [][]time.Time, +func (s *Server) decodeTestRequestStringUnixNullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUnixSeconds, close func() error, rerr error, ) { @@ -56549,17 +57295,15 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Req d := jx.DecodeBytes(buf) - var request [][]time.Time + var request [][]NilStringUnixSeconds if err := func() error { - request = make([][]time.Time, 0) + request = make([][]NilStringUnixSeconds, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []time.Time - elem = make([]time.Time, 0) + var elem []NilStringUnixSeconds + elem = make([]NilStringUnixSeconds, 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 NilStringUnixSeconds + if err := elemElem.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } elem = append(elem, elemElem) @@ -56612,8 +57356,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Req } } -func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Request) ( - req OptNilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixSecondsRequest(r *http.Request) ( + req OptStringUnixSeconds, close func() error, rerr error, ) { @@ -56655,7 +57399,7 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Reque d := jx.DecodeBytes(buf) - var request OptNilStringUnixSeconds + var request OptStringUnixSeconds if err := func() error { request.Reset() if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { @@ -56679,8 +57423,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Reque } } -func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http.Request) ( - req []NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixSecondsArrayRequest(r *http.Request) ( + req []time.Time, close func() error, rerr error, ) { @@ -56722,12 +57466,14 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http. d := jx.DecodeBytes(buf) - var request []NilStringUnixSeconds + var request []time.Time 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) @@ -56753,8 +57499,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http. } } -func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r *http.Request) ( - req [][]NilStringUnixSeconds, +func (s *Server) decodeTestRequestStringUnixSecondsArrayArrayRequest(r *http.Request) ( + req [][]time.Time, close func() error, rerr error, ) { @@ -56796,15 +57542,17 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r * d := jx.DecodeBytes(buf) - var request [][]NilStringUnixSeconds + var request [][]time.Time 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) @@ -56857,8 +57605,8 @@ func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r * } } -func (s *Server) decodeTestResponseAnyRequest(r *http.Request) ( - req string, +func (s *Server) decodeTestRequestStringUnixSecondsNullableRequest(r *http.Request) ( + req OptNilStringUnixSeconds, close func() error, rerr error, ) { @@ -56877,6 +57625,9 @@ func (s *Server) decodeTestResponseAnyRequest(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 { return req, close, errors.Wrap(err, "parse media type") @@ -56884,7 +57635,7 @@ func (s *Server) decodeTestResponseAnyRequest(r *http.Request) ( switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } buf, err := io.ReadAll(r.Body) if err != nil { @@ -56892,16 +57643,15 @@ func (s *Server) decodeTestResponseAnyRequest(r *http.Request) ( } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) - var request string + var request OptNilStringUnixSeconds if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + request.Reset() + if err := request.Decode(d, json.DecodeStringUnixSeconds); err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -56922,8 +57672,8 @@ func (s *Server) decodeTestResponseAnyRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseBooleanRequest(r *http.Request) ( - req string, +func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayRequest(r *http.Request) ( + req []NilStringUnixSeconds, close func() error, rerr error, ) { @@ -56942,6 +57692,9 @@ func (s *Server) decodeTestResponseBooleanRequest(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 { return req, close, errors.Wrap(err, "parse media type") @@ -56949,7 +57702,7 @@ func (s *Server) decodeTestResponseBooleanRequest(r *http.Request) ( switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } buf, err := io.ReadAll(r.Body) if err != nil { @@ -56957,16 +57710,22 @@ func (s *Server) decodeTestResponseBooleanRequest(r *http.Request) ( } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) - var request string + var request []NilStringUnixSeconds if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + 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 } if err := d.Skip(); err != io.EOF { @@ -56987,8 +57746,8 @@ func (s *Server) decodeTestResponseBooleanRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request) ( - req string, +func (s *Server) decodeTestRequestStringUnixSecondsNullableArrayArrayRequest(r *http.Request) ( + req [][]NilStringUnixSeconds, close func() error, rerr error, ) { @@ -57007,6 +57766,9 @@ func (s *Server) decodeTestResponseBooleanArrayRequest(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 { return req, close, errors.Wrap(err, "parse media type") @@ -57014,7 +57776,7 @@ func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request) ( switch { case ct == "application/json": if r.ContentLength == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } buf, err := io.ReadAll(r.Body) if err != nil { @@ -57022,16 +57784,30 @@ func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request) ( } if len(buf) == 0 { - return req, close, validate.ErrBodyRequired + return req, close, nil } d := jx.DecodeBytes(buf) - var request string + var request [][]NilStringUnixSeconds if err := func() error { - v, err := d.Str() - request = string(v) - if err != nil { + 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 } if err := d.Skip(); err != io.EOF { @@ -57046,13 +57822,35 @@ func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request) ( } return req, close, err } + 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) decodeTestResponseBooleanArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseAnyRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -57117,7 +57915,7 @@ func (s *Server) decodeTestResponseBooleanArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseBooleanNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseBooleanRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -57182,7 +57980,7 @@ func (s *Server) decodeTestResponseBooleanNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseBooleanNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseBooleanArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -57247,7 +58045,7 @@ func (s *Server) decodeTestResponseBooleanNullableArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseBooleanNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseBooleanArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -57312,7 +58110,7 @@ func (s *Server) decodeTestResponseBooleanNullableArrayArrayRequest(r *http.Requ } } -func (s *Server) decodeTestResponseEmptyStructRequest(r *http.Request) ( +func (s *Server) decodeTestResponseBooleanNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -57377,7 +58175,7 @@ func (s *Server) decodeTestResponseEmptyStructRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseFormatTestRequest(r *http.Request) ( +func (s *Server) decodeTestResponseBooleanNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -57442,7 +58240,7 @@ func (s *Server) decodeTestResponseFormatTestRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseIntegerRequest(r *http.Request) ( +func (s *Server) decodeTestResponseBooleanNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -57507,7 +58305,202 @@ func (s *Server) decodeTestResponseIntegerRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseIntegerArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseEmptyStructRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseFormatTestRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseIntegerArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64267,7 +65260,397 @@ func (s *Server) decodeTestResponseNumberDoubleNullableArrayArrayRequest(r *http } } -func (s *Server) decodeTestResponseNumberFloatRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberFloatRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseNumberFloatArrayRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseNumberFloatArrayArrayRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseNumberFloatNullableRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseNumberFloatNullableArrayRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseNumberFloatNullableArrayArrayRequest(r *http.Request) ( + 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 + } + 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) + + var request string + if err := func() error { + v, err := d.Str() + request = string(v) + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return req, close, err + } + return request, close, nil + default: + return req, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodeTestResponseNumberInt32Request(r *http.Request) ( req string, close func() error, rerr error, @@ -64332,7 +65715,7 @@ func (s *Server) decodeTestResponseNumberFloatRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberFloatArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt32ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64397,7 +65780,7 @@ func (s *Server) decodeTestResponseNumberFloatArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberFloatArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt32ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64462,7 +65845,7 @@ func (s *Server) decodeTestResponseNumberFloatArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseNumberFloatNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt32NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64527,7 +65910,7 @@ func (s *Server) decodeTestResponseNumberFloatNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberFloatNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt32NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64592,7 +65975,7 @@ func (s *Server) decodeTestResponseNumberFloatNullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseNumberFloatNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt32NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64657,7 +66040,7 @@ func (s *Server) decodeTestResponseNumberFloatNullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestResponseNumberInt32Request(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt64Request(r *http.Request) ( req string, close func() error, rerr error, @@ -64722,7 +66105,7 @@ func (s *Server) decodeTestResponseNumberInt32Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberInt32ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt64ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64787,7 +66170,7 @@ func (s *Server) decodeTestResponseNumberInt32ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberInt32ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt64ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64852,7 +66235,7 @@ func (s *Server) decodeTestResponseNumberInt32ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseNumberInt32NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt64NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64917,7 +66300,7 @@ func (s *Server) decodeTestResponseNumberInt32NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberInt32NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt64NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -64982,7 +66365,7 @@ func (s *Server) decodeTestResponseNumberInt32NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseNumberInt32NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberInt64NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65047,7 +66430,7 @@ func (s *Server) decodeTestResponseNumberInt32NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestResponseNumberInt64Request(r *http.Request) ( +func (s *Server) decodeTestResponseNumberNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65112,7 +66495,7 @@ func (s *Server) decodeTestResponseNumberInt64Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberInt64ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65177,7 +66560,7 @@ func (s *Server) decodeTestResponseNumberInt64ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberInt64ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseNumberNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65242,7 +66625,7 @@ func (s *Server) decodeTestResponseNumberInt64ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseNumberInt64NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65307,7 +66690,7 @@ func (s *Server) decodeTestResponseNumberInt64NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberInt64NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65372,7 +66755,7 @@ func (s *Server) decodeTestResponseNumberInt64NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseNumberInt64NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65437,7 +66820,7 @@ func (s *Server) decodeTestResponseNumberInt64NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestResponseNumberNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBase64Request(r *http.Request) ( req string, close func() error, rerr error, @@ -65502,7 +66885,7 @@ func (s *Server) decodeTestResponseNumberNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBase64ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65567,7 +66950,7 @@ func (s *Server) decodeTestResponseNumberNullableArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseNumberNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBase64ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65632,7 +67015,7 @@ func (s *Server) decodeTestResponseNumberNullableArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBase64NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65697,7 +67080,7 @@ func (s *Server) decodeTestResponseStringRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBase64NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65762,7 +67145,7 @@ func (s *Server) decodeTestResponseStringArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBase64NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65827,7 +67210,7 @@ func (s *Server) decodeTestResponseStringArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringBase64Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringBinaryRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65892,7 +67275,7 @@ func (s *Server) decodeTestResponseStringBase64Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringBase64ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBinaryArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -65957,7 +67340,7 @@ func (s *Server) decodeTestResponseStringBase64ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringBase64ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBinaryArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66022,7 +67405,7 @@ func (s *Server) decodeTestResponseStringBase64ArrayArrayRequest(r *http.Request } } -func (s *Server) decodeTestResponseStringBase64NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBinaryNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66087,7 +67470,7 @@ func (s *Server) decodeTestResponseStringBase64NullableRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringBase64NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBinaryNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66152,7 +67535,7 @@ func (s *Server) decodeTestResponseStringBase64NullableArrayRequest(r *http.Requ } } -func (s *Server) decodeTestResponseStringBase64NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringBinaryNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66217,7 +67600,7 @@ func (s *Server) decodeTestResponseStringBase64NullableArrayArrayRequest(r *http } } -func (s *Server) decodeTestResponseStringBinaryRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringByteRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66282,7 +67665,7 @@ func (s *Server) decodeTestResponseStringBinaryRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringBinaryArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringByteArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66347,7 +67730,7 @@ func (s *Server) decodeTestResponseStringBinaryArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringBinaryArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringByteArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66412,7 +67795,7 @@ func (s *Server) decodeTestResponseStringBinaryArrayArrayRequest(r *http.Request } } -func (s *Server) decodeTestResponseStringBinaryNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringByteNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66477,7 +67860,7 @@ func (s *Server) decodeTestResponseStringBinaryNullableRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringBinaryNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringByteNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66542,7 +67925,7 @@ func (s *Server) decodeTestResponseStringBinaryNullableArrayRequest(r *http.Requ } } -func (s *Server) decodeTestResponseStringBinaryNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringByteNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66607,7 +67990,7 @@ func (s *Server) decodeTestResponseStringBinaryNullableArrayArrayRequest(r *http } } -func (s *Server) decodeTestResponseStringByteRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66672,7 +68055,7 @@ func (s *Server) decodeTestResponseStringByteRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringByteArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66737,7 +68120,7 @@ func (s *Server) decodeTestResponseStringByteArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringByteArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66802,7 +68185,7 @@ func (s *Server) decodeTestResponseStringByteArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringByteNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66867,7 +68250,7 @@ func (s *Server) decodeTestResponseStringByteNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringByteNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66932,7 +68315,7 @@ func (s *Server) decodeTestResponseStringByteNullableArrayRequest(r *http.Reques } } -func (s *Server) decodeTestResponseStringByteNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -66997,7 +68380,7 @@ func (s *Server) decodeTestResponseStringByteNullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestResponseStringDateRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateTimeRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67062,7 +68445,7 @@ func (s *Server) decodeTestResponseStringDateRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringDateArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateTimeArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67127,7 +68510,7 @@ func (s *Server) decodeTestResponseStringDateArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringDateArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateTimeArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67192,7 +68575,7 @@ func (s *Server) decodeTestResponseStringDateArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringDateNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateTimeNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67257,7 +68640,7 @@ func (s *Server) decodeTestResponseStringDateNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringDateNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateTimeNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67322,7 +68705,7 @@ func (s *Server) decodeTestResponseStringDateNullableArrayRequest(r *http.Reques } } -func (s *Server) decodeTestResponseStringDateNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDateTimeNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67387,7 +68770,7 @@ func (s *Server) decodeTestResponseStringDateNullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestResponseStringDateTimeRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDurationRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67452,7 +68835,7 @@ func (s *Server) decodeTestResponseStringDateTimeRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringDateTimeArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDurationArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67517,7 +68900,7 @@ func (s *Server) decodeTestResponseStringDateTimeArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringDateTimeArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDurationArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67582,7 +68965,7 @@ func (s *Server) decodeTestResponseStringDateTimeArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringDateTimeNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDurationNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67647,7 +69030,7 @@ func (s *Server) decodeTestResponseStringDateTimeNullableRequest(r *http.Request } } -func (s *Server) decodeTestResponseStringDateTimeNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDurationNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67712,7 +69095,7 @@ func (s *Server) decodeTestResponseStringDateTimeNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestResponseStringDateTimeNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringDurationNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67777,7 +69160,7 @@ func (s *Server) decodeTestResponseStringDateTimeNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestResponseStringDurationRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringEmailRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67842,7 +69225,7 @@ func (s *Server) decodeTestResponseStringDurationRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringDurationArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringEmailArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67907,7 +69290,7 @@ func (s *Server) decodeTestResponseStringDurationArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringDurationArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringEmailArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -67972,7 +69355,7 @@ func (s *Server) decodeTestResponseStringDurationArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringDurationNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringEmailNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68037,7 +69420,7 @@ func (s *Server) decodeTestResponseStringDurationNullableRequest(r *http.Request } } -func (s *Server) decodeTestResponseStringDurationNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringEmailNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68102,7 +69485,7 @@ func (s *Server) decodeTestResponseStringDurationNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestResponseStringDurationNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringEmailNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68167,7 +69550,7 @@ func (s *Server) decodeTestResponseStringDurationNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestResponseStringEmailRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat32Request(r *http.Request) ( req string, close func() error, rerr error, @@ -68232,7 +69615,7 @@ func (s *Server) decodeTestResponseStringEmailRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringEmailArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat32ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68297,7 +69680,7 @@ func (s *Server) decodeTestResponseStringEmailArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringEmailArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat32ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68362,7 +69745,7 @@ func (s *Server) decodeTestResponseStringEmailArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringEmailNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat32NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68427,7 +69810,7 @@ func (s *Server) decodeTestResponseStringEmailNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringEmailNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat32NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68492,7 +69875,7 @@ func (s *Server) decodeTestResponseStringEmailNullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringEmailNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat32NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68557,7 +69940,7 @@ func (s *Server) decodeTestResponseStringEmailNullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestResponseStringFloat32Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat64Request(r *http.Request) ( req string, close func() error, rerr error, @@ -68622,7 +70005,7 @@ func (s *Server) decodeTestResponseStringFloat32Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringFloat32ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat64ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68687,7 +70070,7 @@ func (s *Server) decodeTestResponseStringFloat32ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringFloat32ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat64ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68752,7 +70135,7 @@ func (s *Server) decodeTestResponseStringFloat32ArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestResponseStringFloat32NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat64NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68817,7 +70200,7 @@ func (s *Server) decodeTestResponseStringFloat32NullableRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringFloat32NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat64NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68882,7 +70265,7 @@ func (s *Server) decodeTestResponseStringFloat32NullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestResponseStringFloat32NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringFloat64NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -68947,7 +70330,7 @@ func (s *Server) decodeTestResponseStringFloat32NullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestResponseStringFloat64Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringHostnameRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69012,7 +70395,7 @@ func (s *Server) decodeTestResponseStringFloat64Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringFloat64ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringHostnameArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69077,7 +70460,7 @@ func (s *Server) decodeTestResponseStringFloat64ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringFloat64ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringHostnameArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69142,7 +70525,7 @@ func (s *Server) decodeTestResponseStringFloat64ArrayArrayRequest(r *http.Reques } } -func (s *Server) decodeTestResponseStringFloat64NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringHostnameNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69207,7 +70590,7 @@ func (s *Server) decodeTestResponseStringFloat64NullableRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringFloat64NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringHostnameNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69272,7 +70655,7 @@ func (s *Server) decodeTestResponseStringFloat64NullableArrayRequest(r *http.Req } } -func (s *Server) decodeTestResponseStringFloat64NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringHostnameNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69337,7 +70720,7 @@ func (s *Server) decodeTestResponseStringFloat64NullableArrayArrayRequest(r *htt } } -func (s *Server) decodeTestResponseStringHostnameRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIPRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69402,7 +70785,7 @@ func (s *Server) decodeTestResponseStringHostnameRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringHostnameArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIPArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69467,7 +70850,7 @@ func (s *Server) decodeTestResponseStringHostnameArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringHostnameArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIPArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69532,7 +70915,7 @@ func (s *Server) decodeTestResponseStringHostnameArrayArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringHostnameNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIPNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69597,7 +70980,7 @@ func (s *Server) decodeTestResponseStringHostnameNullableRequest(r *http.Request } } -func (s *Server) decodeTestResponseStringHostnameNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIPNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69662,7 +71045,7 @@ func (s *Server) decodeTestResponseStringHostnameNullableArrayRequest(r *http.Re } } -func (s *Server) decodeTestResponseStringHostnameNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIPNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69727,7 +71110,7 @@ func (s *Server) decodeTestResponseStringHostnameNullableArrayArrayRequest(r *ht } } -func (s *Server) decodeTestResponseStringIPRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIntRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69792,7 +71175,7 @@ func (s *Server) decodeTestResponseStringIPRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIPArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt16Request(r *http.Request) ( req string, close func() error, rerr error, @@ -69857,7 +71240,7 @@ func (s *Server) decodeTestResponseStringIPArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIPArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt16ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69922,7 +71305,7 @@ func (s *Server) decodeTestResponseStringIPArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIPNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt16ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -69987,7 +71370,7 @@ func (s *Server) decodeTestResponseStringIPNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIPNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt16NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70052,7 +71435,7 @@ func (s *Server) decodeTestResponseStringIPNullableArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringIPNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt16NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70117,7 +71500,7 @@ func (s *Server) decodeTestResponseStringIPNullableArrayArrayRequest(r *http.Req } } -func (s *Server) decodeTestResponseStringIntRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt16NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70182,7 +71565,7 @@ func (s *Server) decodeTestResponseStringIntRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt16Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt32Request(r *http.Request) ( req string, close func() error, rerr error, @@ -70247,7 +71630,7 @@ func (s *Server) decodeTestResponseStringInt16Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt16ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt32ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70312,7 +71695,7 @@ func (s *Server) decodeTestResponseStringInt16ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt16ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt32ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70377,7 +71760,7 @@ func (s *Server) decodeTestResponseStringInt16ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringInt16NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt32NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70442,7 +71825,7 @@ func (s *Server) decodeTestResponseStringInt16NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt16NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt32NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70507,7 +71890,7 @@ func (s *Server) decodeTestResponseStringInt16NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringInt16NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt32NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70572,7 +71955,7 @@ func (s *Server) decodeTestResponseStringInt16NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestResponseStringInt32Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt64Request(r *http.Request) ( req string, close func() error, rerr error, @@ -70637,7 +72020,7 @@ func (s *Server) decodeTestResponseStringInt32Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt32ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt64ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70702,7 +72085,7 @@ func (s *Server) decodeTestResponseStringInt32ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt32ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt64ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70767,7 +72150,7 @@ func (s *Server) decodeTestResponseStringInt32ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringInt32NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt64NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70832,7 +72215,7 @@ func (s *Server) decodeTestResponseStringInt32NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt32NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt64NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70897,7 +72280,7 @@ func (s *Server) decodeTestResponseStringInt32NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringInt32NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt64NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -70962,7 +72345,7 @@ func (s *Server) decodeTestResponseStringInt32NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestResponseStringInt64Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt8Request(r *http.Request) ( req string, close func() error, rerr error, @@ -71027,7 +72410,7 @@ func (s *Server) decodeTestResponseStringInt64Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt64ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt8ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71092,7 +72475,7 @@ func (s *Server) decodeTestResponseStringInt64ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt64ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt8ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71157,7 +72540,7 @@ func (s *Server) decodeTestResponseStringInt64ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringInt64NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt8NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71222,7 +72605,7 @@ func (s *Server) decodeTestResponseStringInt64NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt64NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt8NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71287,7 +72670,7 @@ func (s *Server) decodeTestResponseStringInt64NullableArrayRequest(r *http.Reque } } -func (s *Server) decodeTestResponseStringInt64NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringInt8NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71352,7 +72735,7 @@ func (s *Server) decodeTestResponseStringInt64NullableArrayArrayRequest(r *http. } } -func (s *Server) decodeTestResponseStringInt8Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringIntArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71417,7 +72800,7 @@ func (s *Server) decodeTestResponseStringInt8Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt8ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIntArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71482,7 +72865,7 @@ func (s *Server) decodeTestResponseStringInt8ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt8ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIntNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71547,7 +72930,7 @@ func (s *Server) decodeTestResponseStringInt8ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringInt8NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIntNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71612,7 +72995,7 @@ func (s *Server) decodeTestResponseStringInt8NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringInt8NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIntNullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71677,7 +73060,7 @@ func (s *Server) decodeTestResponseStringInt8NullableArrayRequest(r *http.Reques } } -func (s *Server) decodeTestResponseStringInt8NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv4Request(r *http.Request) ( req string, close func() error, rerr error, @@ -71742,7 +73125,7 @@ func (s *Server) decodeTestResponseStringInt8NullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestResponseStringIntArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv4ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71807,7 +73190,7 @@ func (s *Server) decodeTestResponseStringIntArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIntArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv4ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71872,7 +73255,7 @@ func (s *Server) decodeTestResponseStringIntArrayArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIntNullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv4NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -71937,7 +73320,7 @@ func (s *Server) decodeTestResponseStringIntNullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIntNullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv4NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72002,7 +73385,7 @@ func (s *Server) decodeTestResponseStringIntNullableArrayRequest(r *http.Request } } -func (s *Server) decodeTestResponseStringIntNullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv4NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72067,7 +73450,7 @@ func (s *Server) decodeTestResponseStringIntNullableArrayArrayRequest(r *http.Re } } -func (s *Server) decodeTestResponseStringIpv4Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv6Request(r *http.Request) ( req string, close func() error, rerr error, @@ -72132,7 +73515,7 @@ func (s *Server) decodeTestResponseStringIpv4Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIpv4ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv6ArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72197,7 +73580,7 @@ func (s *Server) decodeTestResponseStringIpv4ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIpv4ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv6ArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72262,7 +73645,7 @@ func (s *Server) decodeTestResponseStringIpv4ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringIpv4NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv6NullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72327,7 +73710,7 @@ func (s *Server) decodeTestResponseStringIpv4NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIpv4NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv6NullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72392,7 +73775,7 @@ func (s *Server) decodeTestResponseStringIpv4NullableArrayRequest(r *http.Reques } } -func (s *Server) decodeTestResponseStringIpv4NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringIpv6NullableArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72457,7 +73840,7 @@ func (s *Server) decodeTestResponseStringIpv4NullableArrayArrayRequest(r *http.R } } -func (s *Server) decodeTestResponseStringIpv6Request(r *http.Request) ( +func (s *Server) decodeTestResponseStringMACRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72522,7 +73905,7 @@ func (s *Server) decodeTestResponseStringIpv6Request(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIpv6ArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringMACArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72587,7 +73970,7 @@ func (s *Server) decodeTestResponseStringIpv6ArrayRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIpv6ArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringMACArrayArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72652,7 +74035,7 @@ func (s *Server) decodeTestResponseStringIpv6ArrayArrayRequest(r *http.Request) } } -func (s *Server) decodeTestResponseStringIpv6NullableRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringMACNullableRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72717,7 +74100,7 @@ func (s *Server) decodeTestResponseStringIpv6NullableRequest(r *http.Request) ( } } -func (s *Server) decodeTestResponseStringIpv6NullableArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringMACNullableArrayRequest(r *http.Request) ( req string, close func() error, rerr error, @@ -72782,7 +74165,7 @@ func (s *Server) decodeTestResponseStringIpv6NullableArrayRequest(r *http.Reques } } -func (s *Server) decodeTestResponseStringIpv6NullableArrayArrayRequest(r *http.Request) ( +func (s *Server) decodeTestResponseStringMACNullableArrayArrayRequest(r *http.Request) ( 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 8f0e6464a..b7c012b37 100644 --- a/examples/ex_test_format/oas_request_encoders_gen.go +++ b/examples/ex_test_format/oas_request_encoders_gen.go @@ -4,6 +4,7 @@ package api import ( "bytes" + "net" "net/http" "net/netip" "net/url" @@ -7326,6 +7327,114 @@ func encodeTestRequestRequiredStringIpv6NullableArrayArrayRequest( return nil } +func encodeTestRequestRequiredStringMACRequest( + req net.HardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + json.EncodeMAC(e, req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestRequiredStringMACArrayRequest( + req []net.HardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.ArrStart() + for _, elem := range req { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestRequiredStringMACArrayArrayRequest( + req [][]net.HardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestRequiredStringMACNullableRequest( + req NilHardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + req.Encode(e) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestRequiredStringMACNullableArrayRequest( + req []NilHardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.ArrStart() + for _, elem := range req { + elem.Encode(e) + } + e.ArrEnd() + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestRequiredStringMACNullableArrayArrayRequest( + req [][]NilHardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + 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 encodeTestRequestRequiredStringNullableRequest( req NilString, r *http.Request, @@ -11248,6 +11357,134 @@ func encodeTestRequestStringIpv6NullableArrayArrayRequest( return nil } +func encodeTestRequestStringMACRequest( + req OptHardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := new(jx.Encoder) + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestStringMACArrayRequest( + req []net.HardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + if req != nil { + e.ArrStart() + for _, elem := range req { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestStringMACArrayArrayRequest( + req [][]net.HardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + if req != nil { + e.ArrStart() + for _, elem := range req { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestStringMACNullableRequest( + req OptNilHardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := new(jx.Encoder) + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestRequestStringMACNullableArrayRequest( + req []NilHardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + 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 encodeTestRequestStringMACNullableArrayArrayRequest( + req [][]NilHardwareAddr, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + 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 encodeTestRequestStringNullableRequest( req OptNilString, r *http.Request, @@ -16548,6 +16785,90 @@ func encodeTestResponseStringIpv6NullableArrayArrayRequest( return nil } +func encodeTestResponseStringMACRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestResponseStringMACArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestResponseStringMACArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestResponseStringMACNullableRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestResponseStringMACNullableArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeTestResponseStringMACNullableArrayArrayRequest( + req string, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + e.Str(req) + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + func encodeTestResponseStringNullableRequest( 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 4fab4d1df..8246864c5 100644 --- a/examples/ex_test_format/oas_response_decoders_gen.go +++ b/examples/ex_test_format/oas_response_decoders_gen.go @@ -6,6 +6,7 @@ import ( "fmt" "io" "mime" + "net" "net/http" "net/netip" "net/url" @@ -15682,7 +15683,7 @@ func decodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringMACResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -15723,7 +15724,7 @@ func decodeTestRequestRequiredStringNullableResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringMACArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -15764,7 +15765,7 @@ func decodeTestRequestRequiredStringNullableArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringMACArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -15805,7 +15806,7 @@ func decodeTestRequestRequiredStringNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringMACNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -15846,7 +15847,7 @@ func decodeTestRequestRequiredStringPasswordResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringMACNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -15887,7 +15888,7 @@ func decodeTestRequestRequiredStringPasswordArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringMACNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -15928,7 +15929,7 @@ func decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -15969,7 +15970,7 @@ func decodeTestRequestRequiredStringPasswordNullableResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16010,7 +16011,7 @@ func decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16051,7 +16052,7 @@ func decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp *htt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringPasswordResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16092,7 +16093,7 @@ func decodeTestRequestRequiredStringTimeResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringPasswordArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16133,7 +16134,7 @@ func decodeTestRequestRequiredStringTimeArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringPasswordArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16174,7 +16175,7 @@ func decodeTestRequestRequiredStringTimeArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringPasswordNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16215,7 +16216,7 @@ func decodeTestRequestRequiredStringTimeNullableResponse(resp *http.Response) (r return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringPasswordNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16256,7 +16257,7 @@ func decodeTestRequestRequiredStringTimeNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringPasswordNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16297,7 +16298,7 @@ func decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURIResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringTimeResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16338,7 +16339,7 @@ func decodeTestRequestRequiredStringURIResponse(resp *http.Response) (res *Error return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURIArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringTimeArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16379,7 +16380,7 @@ func decodeTestRequestRequiredStringURIArrayResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURIArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringTimeArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16420,7 +16421,7 @@ func decodeTestRequestRequiredStringURIArrayArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURINullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringTimeNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16461,7 +16462,7 @@ func decodeTestRequestRequiredStringURINullableResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURINullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringTimeNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16502,7 +16503,7 @@ func decodeTestRequestRequiredStringURINullableArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringTimeNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16543,7 +16544,7 @@ func decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringURIResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16584,7 +16585,7 @@ func decodeTestRequestRequiredStringUUIDResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringURIArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16625,7 +16626,7 @@ func decodeTestRequestRequiredStringUUIDArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringURIArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16666,7 +16667,7 @@ func decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringURINullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16707,7 +16708,7 @@ func decodeTestRequestRequiredStringUUIDNullableResponse(resp *http.Response) (r return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringURINullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16748,7 +16749,7 @@ func decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringURINullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16789,7 +16790,7 @@ func decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUintResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUUIDResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16830,7 +16831,7 @@ func decodeTestRequestRequiredStringUintResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint16Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUUIDArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16871,7 +16872,7 @@ func decodeTestRequestRequiredStringUint16Response(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint16ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUUIDArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16912,7 +16913,7 @@ func decodeTestRequestRequiredStringUint16ArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint16ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUUIDNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16953,7 +16954,7 @@ func decodeTestRequestRequiredStringUint16ArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint16NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUUIDNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -16994,7 +16995,7 @@ func decodeTestRequestRequiredStringUint16NullableResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint16NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUUIDNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17035,7 +17036,7 @@ func decodeTestRequestRequiredStringUint16NullableArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint16NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUintResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17076,7 +17077,7 @@ func decodeTestRequestRequiredStringUint16NullableArrayArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint32Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint16Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17117,7 +17118,7 @@ func decodeTestRequestRequiredStringUint32Response(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint32ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint16ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17158,7 +17159,7 @@ func decodeTestRequestRequiredStringUint32ArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint32ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint16ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17199,7 +17200,7 @@ func decodeTestRequestRequiredStringUint32ArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint32NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint16NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17240,7 +17241,7 @@ func decodeTestRequestRequiredStringUint32NullableResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint32NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint16NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17281,7 +17282,7 @@ func decodeTestRequestRequiredStringUint32NullableArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint32NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint16NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17322,7 +17323,7 @@ func decodeTestRequestRequiredStringUint32NullableArrayArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint64Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint32Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17363,7 +17364,7 @@ func decodeTestRequestRequiredStringUint64Response(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint64ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint32ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17404,7 +17405,7 @@ func decodeTestRequestRequiredStringUint64ArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint64ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint32ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17445,7 +17446,7 @@ func decodeTestRequestRequiredStringUint64ArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint64NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint32NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17486,7 +17487,7 @@ func decodeTestRequestRequiredStringUint64NullableResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint64NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint32NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17527,7 +17528,7 @@ func decodeTestRequestRequiredStringUint64NullableArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint64NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint32NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17568,7 +17569,7 @@ func decodeTestRequestRequiredStringUint64NullableArrayArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint8Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint64Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17609,7 +17610,7 @@ func decodeTestRequestRequiredStringUint8Response(resp *http.Response) (res *Err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint8ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint64ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17650,7 +17651,7 @@ func decodeTestRequestRequiredStringUint8ArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint8ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint64ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17691,7 +17692,7 @@ func decodeTestRequestRequiredStringUint8ArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint8NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint64NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17732,7 +17733,7 @@ func decodeTestRequestRequiredStringUint8NullableResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint8NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint64NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17773,7 +17774,7 @@ func decodeTestRequestRequiredStringUint8NullableArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUint8NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint64NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17814,7 +17815,7 @@ func decodeTestRequestRequiredStringUint8NullableArrayArrayResponse(resp *http.R return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUintArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint8Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17855,7 +17856,7 @@ func decodeTestRequestRequiredStringUintArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUintArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint8ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17896,7 +17897,7 @@ func decodeTestRequestRequiredStringUintArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUintNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint8ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17937,7 +17938,7 @@ func decodeTestRequestRequiredStringUintNullableResponse(resp *http.Response) (r return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUintNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint8NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -17978,7 +17979,7 @@ func decodeTestRequestRequiredStringUintNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUintNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint8NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18019,7 +18020,7 @@ func decodeTestRequestRequiredStringUintNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUint8NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18060,7 +18061,7 @@ func decodeTestRequestRequiredStringUnixResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUintArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18101,7 +18102,7 @@ func decodeTestRequestRequiredStringUnixArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUintArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18142,7 +18143,7 @@ func decodeTestRequestRequiredStringUnixArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUintNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18183,7 +18184,7 @@ func decodeTestRequestRequiredStringUnixMicroResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUintNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18224,7 +18225,7 @@ func decodeTestRequestRequiredStringUnixMicroArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUintNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18265,7 +18266,7 @@ func decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18306,7 +18307,7 @@ func decodeTestRequestRequiredStringUnixMicroNullableResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18347,7 +18348,7 @@ func decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18388,7 +18389,7 @@ func decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp *ht return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMicroResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18429,7 +18430,7 @@ func decodeTestRequestRequiredStringUnixMilliResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMicroArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18470,7 +18471,7 @@ func decodeTestRequestRequiredStringUnixMilliArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMicroArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18511,7 +18512,7 @@ func decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMicroNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18552,7 +18553,7 @@ func decodeTestRequestRequiredStringUnixMilliNullableResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMicroNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18593,7 +18594,7 @@ func decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMicroNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18634,7 +18635,7 @@ func decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp *ht return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMilliResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18675,7 +18676,7 @@ func decodeTestRequestRequiredStringUnixNanoResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMilliArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18716,7 +18717,7 @@ func decodeTestRequestRequiredStringUnixNanoArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMilliArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18757,7 +18758,7 @@ func decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMilliNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18798,7 +18799,7 @@ func decodeTestRequestRequiredStringUnixNanoNullableResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMilliNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18839,7 +18840,7 @@ func decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixMilliNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18880,7 +18881,7 @@ func decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp *htt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNanoResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18921,7 +18922,7 @@ func decodeTestRequestRequiredStringUnixNullableResponse(resp *http.Response) (r return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNanoArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -18962,7 +18963,7 @@ func decodeTestRequestRequiredStringUnixNullableArrayResponse(resp *http.Respons return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNanoArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19003,7 +19004,7 @@ func decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp *http.Re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNanoNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19044,7 +19045,7 @@ func decodeTestRequestRequiredStringUnixSecondsResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNanoNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19085,7 +19086,7 @@ func decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNanoNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19126,7 +19127,7 @@ func decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp *http.Res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19167,7 +19168,7 @@ func decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19208,7 +19209,7 @@ func decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp *http. return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19249,7 +19250,7 @@ func decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixSecondsResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19290,7 +19291,7 @@ func decodeTestRequestStringResponse(resp *http.Response) (res *Error, _ error) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixSecondsArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19331,7 +19332,7 @@ func decodeTestRequestStringArrayResponse(resp *http.Response) (res *Error, _ er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixSecondsArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19372,7 +19373,7 @@ func decodeTestRequestStringArrayArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBase64Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixSecondsNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19413,7 +19414,7 @@ func decodeTestRequestStringBase64Response(resp *http.Response) (res *Error, _ e return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBase64ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixSecondsNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19454,7 +19455,7 @@ func decodeTestRequestStringBase64ArrayResponse(resp *http.Response) (res *Error return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBase64ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestRequiredStringUnixSecondsNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19495,7 +19496,7 @@ func decodeTestRequestStringBase64ArrayArrayResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBase64NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19536,7 +19537,7 @@ func decodeTestRequestStringBase64NullableResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBase64NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19577,7 +19578,7 @@ func decodeTestRequestStringBase64NullableArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBase64NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19618,7 +19619,7 @@ func decodeTestRequestStringBase64NullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBase64Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19659,7 +19660,7 @@ func decodeTestRequestStringBinaryResponse(resp *http.Response) (res *Error, _ e return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBase64ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19700,7 +19701,7 @@ func decodeTestRequestStringBinaryArrayResponse(resp *http.Response) (res *Error return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBase64ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19741,7 +19742,7 @@ func decodeTestRequestStringBinaryArrayArrayResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBase64NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19782,7 +19783,7 @@ func decodeTestRequestStringBinaryNullableResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBase64NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19823,7 +19824,7 @@ func decodeTestRequestStringBinaryNullableArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringBinaryNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBase64NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19864,7 +19865,7 @@ func decodeTestRequestStringBinaryNullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBinaryResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19905,7 +19906,7 @@ func decodeTestRequestStringByteResponse(resp *http.Response) (res *Error, _ err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBinaryArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19946,7 +19947,7 @@ func decodeTestRequestStringByteArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBinaryArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -19987,7 +19988,7 @@ func decodeTestRequestStringByteArrayArrayResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBinaryNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -20028,7 +20029,7 @@ func decodeTestRequestStringByteNullableResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBinaryNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -20069,7 +20070,7 @@ func decodeTestRequestStringByteNullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringByteNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringBinaryNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -20110,7 +20111,7 @@ func decodeTestRequestStringByteNullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringByteResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -20151,7 +20152,7 @@ func decodeTestRequestStringDateResponse(resp *http.Response) (res *Error, _ err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringByteArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -20192,7 +20193,253 @@ func decodeTestRequestStringDateArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringDateArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringByteArrayArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringByteNullableResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringByteNullableArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringByteNullableArrayArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringDateResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringDateArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringDateArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -23800,7 +24047,7 @@ func decodeTestRequestStringIpv6NullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringMACResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -23841,7 +24088,7 @@ func decodeTestRequestStringNullableResponse(resp *http.Response) (res *Error, _ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringMACArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -23882,7 +24129,7 @@ func decodeTestRequestStringNullableArrayResponse(resp *http.Response) (res *Err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringMACArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -23923,7 +24170,7 @@ func decodeTestRequestStringNullableArrayArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringMACNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -23964,7 +24211,7 @@ func decodeTestRequestStringPasswordResponse(resp *http.Response) (res *Error, _ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringMACNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24005,7 +24252,7 @@ func decodeTestRequestStringPasswordArrayResponse(resp *http.Response) (res *Err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringMACNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24046,7 +24293,7 @@ func decodeTestRequestStringPasswordArrayArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24087,7 +24334,7 @@ func decodeTestRequestStringPasswordNullableResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24128,7 +24375,7 @@ func decodeTestRequestStringPasswordNullableArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringPasswordNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24169,7 +24416,7 @@ func decodeTestRequestStringPasswordNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringPasswordResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24210,7 +24457,7 @@ func decodeTestRequestStringTimeResponse(resp *http.Response) (res *Error, _ err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringPasswordArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24251,7 +24498,7 @@ func decodeTestRequestStringTimeArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringPasswordArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24292,7 +24539,7 @@ func decodeTestRequestStringTimeArrayArrayResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringPasswordNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24333,7 +24580,7 @@ func decodeTestRequestStringTimeNullableResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringPasswordNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24374,7 +24621,7 @@ func decodeTestRequestStringTimeNullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringTimeNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringPasswordNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24415,7 +24662,7 @@ func decodeTestRequestStringTimeNullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURIResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringTimeResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24456,7 +24703,7 @@ func decodeTestRequestStringURIResponse(resp *http.Response) (res *Error, _ erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURIArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringTimeArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24497,7 +24744,7 @@ func decodeTestRequestStringURIArrayResponse(resp *http.Response) (res *Error, _ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURIArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringTimeArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24538,7 +24785,7 @@ func decodeTestRequestStringURIArrayArrayResponse(resp *http.Response) (res *Err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURINullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringTimeNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24579,7 +24826,7 @@ func decodeTestRequestStringURINullableResponse(resp *http.Response) (res *Error return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURINullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringTimeNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24620,7 +24867,7 @@ func decodeTestRequestStringURINullableArrayResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringURINullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringTimeNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24661,7 +24908,7 @@ func decodeTestRequestStringURINullableArrayArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringURIResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24702,7 +24949,7 @@ func decodeTestRequestStringUUIDResponse(resp *http.Response) (res *Error, _ err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringURIArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24743,7 +24990,7 @@ func decodeTestRequestStringUUIDArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringURIArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24784,7 +25031,7 @@ func decodeTestRequestStringUUIDArrayArrayResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringURINullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24825,7 +25072,7 @@ func decodeTestRequestStringUUIDNullableResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringURINullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24866,7 +25113,7 @@ func decodeTestRequestStringUUIDNullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUUIDNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringURINullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24907,7 +25154,7 @@ func decodeTestRequestStringUUIDNullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUintResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUUIDResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24948,7 +25195,7 @@ func decodeTestRequestStringUintResponse(resp *http.Response) (res *Error, _ err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint16Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUUIDArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -24989,212 +25236,7 @@ func decodeTestRequestStringUint16Response(resp *http.Response) (res *Error, _ e return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint16ArrayResponse(resp *http.Response) (res *Error, _ 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": - buf, err := io.ReadAll(resp.Body) - if err != nil { - return res, err - } - d := jx.DecodeBytes(buf) - - var response Error - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return res, err - } - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - } - return res, validate.UnexpectedStatusCode(resp.StatusCode) -} - -func decodeTestRequestStringUint16ArrayArrayResponse(resp *http.Response) (res *Error, _ 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": - buf, err := io.ReadAll(resp.Body) - if err != nil { - return res, err - } - d := jx.DecodeBytes(buf) - - var response Error - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return res, err - } - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - } - return res, validate.UnexpectedStatusCode(resp.StatusCode) -} - -func decodeTestRequestStringUint16NullableResponse(resp *http.Response) (res *Error, _ 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": - buf, err := io.ReadAll(resp.Body) - if err != nil { - return res, err - } - d := jx.DecodeBytes(buf) - - var response Error - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return res, err - } - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - } - return res, validate.UnexpectedStatusCode(resp.StatusCode) -} - -func decodeTestRequestStringUint16NullableArrayResponse(resp *http.Response) (res *Error, _ 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": - buf, err := io.ReadAll(resp.Body) - if err != nil { - return res, err - } - d := jx.DecodeBytes(buf) - - var response Error - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return res, err - } - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - } - return res, validate.UnexpectedStatusCode(resp.StatusCode) -} - -func decodeTestRequestStringUint16NullableArrayArrayResponse(resp *http.Response) (res *Error, _ 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": - buf, err := io.ReadAll(resp.Body) - if err != nil { - return res, err - } - d := jx.DecodeBytes(buf) - - var response Error - if err := func() error { - if err := response.Decode(d); err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return res, err - } - return &response, nil - default: - return res, validate.InvalidContentType(ct) - } - } - return res, validate.UnexpectedStatusCode(resp.StatusCode) -} - -func decodeTestRequestStringUint32Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUUIDArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25235,7 +25277,7 @@ func decodeTestRequestStringUint32Response(resp *http.Response) (res *Error, _ e return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint32ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUUIDNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25276,7 +25318,7 @@ func decodeTestRequestStringUint32ArrayResponse(resp *http.Response) (res *Error return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint32ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUUIDNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25317,7 +25359,7 @@ func decodeTestRequestStringUint32ArrayArrayResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint32NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUUIDNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25358,7 +25400,7 @@ func decodeTestRequestStringUint32NullableResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint32NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUintResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25399,7 +25441,7 @@ func decodeTestRequestStringUint32NullableArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint32NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint16Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25440,7 +25482,7 @@ func decodeTestRequestStringUint32NullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint64Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint16ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25481,7 +25523,7 @@ func decodeTestRequestStringUint64Response(resp *http.Response) (res *Error, _ e return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint64ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint16ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25522,7 +25564,7 @@ func decodeTestRequestStringUint64ArrayResponse(resp *http.Response) (res *Error return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint64ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint16NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25563,7 +25605,7 @@ func decodeTestRequestStringUint64ArrayArrayResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint64NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint16NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25604,7 +25646,7 @@ func decodeTestRequestStringUint64NullableResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint64NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint16NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25645,7 +25687,7 @@ func decodeTestRequestStringUint64NullableArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint64NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint32Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25686,7 +25728,7 @@ func decodeTestRequestStringUint64NullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint8Response(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint32ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25727,7 +25769,7 @@ func decodeTestRequestStringUint8Response(resp *http.Response) (res *Error, _ er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint8ArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint32ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25768,7 +25810,7 @@ func decodeTestRequestStringUint8ArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint8ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint32NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25809,7 +25851,7 @@ func decodeTestRequestStringUint8ArrayArrayResponse(resp *http.Response) (res *E return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint8NullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint32NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25850,7 +25892,7 @@ func decodeTestRequestStringUint8NullableResponse(resp *http.Response) (res *Err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint8NullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint32NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25891,7 +25933,7 @@ func decodeTestRequestStringUint8NullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUint8NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint64Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25932,7 +25974,7 @@ func decodeTestRequestStringUint8NullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUintArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint64ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -25973,7 +26015,7 @@ func decodeTestRequestStringUintArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUintArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint64ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26014,7 +26056,7 @@ func decodeTestRequestStringUintArrayArrayResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUintNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint64NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26055,7 +26097,7 @@ func decodeTestRequestStringUintNullableResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUintNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint64NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26096,7 +26138,7 @@ func decodeTestRequestStringUintNullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUintNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint64NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26137,7 +26179,7 @@ func decodeTestRequestStringUintNullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint8Response(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26178,7 +26220,7 @@ func decodeTestRequestStringUnixResponse(resp *http.Response) (res *Error, _ err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint8ArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26219,7 +26261,7 @@ func decodeTestRequestStringUnixArrayResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint8ArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26260,7 +26302,7 @@ func decodeTestRequestStringUnixArrayArrayResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint8NullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26301,7 +26343,7 @@ func decodeTestRequestStringUnixMicroResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint8NullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26342,7 +26384,7 @@ func decodeTestRequestStringUnixMicroArrayResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUint8NullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26383,7 +26425,7 @@ func decodeTestRequestStringUnixMicroArrayArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUintArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26424,7 +26466,7 @@ func decodeTestRequestStringUnixMicroNullableResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUintArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26465,7 +26507,7 @@ func decodeTestRequestStringUnixMicroNullableArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUintNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26506,7 +26548,7 @@ func decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUintNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26547,7 +26589,7 @@ func decodeTestRequestStringUnixMilliResponse(resp *http.Response) (res *Error, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUintNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26588,7 +26630,7 @@ func decodeTestRequestStringUnixMilliArrayResponse(resp *http.Response) (res *Er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26629,7 +26671,7 @@ func decodeTestRequestStringUnixMilliArrayArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26670,7 +26712,7 @@ func decodeTestRequestStringUnixMilliNullableResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26711,7 +26753,7 @@ func decodeTestRequestStringUnixMilliNullableArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMicroResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26752,7 +26794,7 @@ func decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp *http.Respo return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMicroArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26793,7 +26835,7 @@ func decodeTestRequestStringUnixNanoResponse(resp *http.Response) (res *Error, _ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMicroArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26834,7 +26876,7 @@ func decodeTestRequestStringUnixNanoArrayResponse(resp *http.Response) (res *Err return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMicroNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26875,7 +26917,7 @@ func decodeTestRequestStringUnixNanoArrayArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMicroNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26916,7 +26958,7 @@ func decodeTestRequestStringUnixNanoNullableResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMicroNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26957,7 +26999,7 @@ func decodeTestRequestStringUnixNanoNullableArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMilliResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -26998,7 +27040,7 @@ func decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp *http.Respon return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMilliArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -27039,7 +27081,7 @@ func decodeTestRequestStringUnixNullableResponse(resp *http.Response) (res *Erro return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMilliArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -27080,7 +27122,7 @@ func decodeTestRequestStringUnixNullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMilliNullableResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -27121,7 +27163,7 @@ func decodeTestRequestStringUnixNullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMilliNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -27162,7 +27204,7 @@ func decodeTestRequestStringUnixSecondsResponse(resp *http.Response) (res *Error return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixMilliNullableArrayArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -27203,7 +27245,7 @@ func decodeTestRequestStringUnixSecondsArrayResponse(resp *http.Response) (res * return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsArrayArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixNanoResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -27244,7 +27286,7 @@ func decodeTestRequestStringUnixSecondsArrayArrayResponse(resp *http.Response) ( return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsNullableResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixNanoArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -27285,7 +27327,458 @@ func decodeTestRequestStringUnixSecondsNullableResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestRequestStringUnixSecondsNullableArrayResponse(resp *http.Response) (res *Error, _ error) { +func decodeTestRequestStringUnixNanoArrayArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoNullableResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoNullableArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNanoNullableArrayArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNullableResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNullableArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixNullableArrayArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsArrayArrayResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsNullableResponse(resp *http.Response) (res *Error, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestRequestStringUnixSecondsNullableArrayResponse(resp *http.Response) (res *Error, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -40793,7 +41286,236 @@ func decodeTestResponseStringIntResponse(resp *http.Response) (res int, _ error) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt16Response(resp *http.Response) (res int16, _ error) { +func decodeTestResponseStringInt16Response(resp *http.Response) (res int16, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response int16 + if err := func() error { + v, err := json.DecodeStringInt16(d) + response = v + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseStringInt16ArrayResponse(resp *http.Response) (res []int16, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response []int16 + if err := func() error { + response = make([]int16, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem int16 + v, err := json.DecodeStringInt16(d) + elem = v + if err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if response == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseStringInt16ArrayArrayResponse(resp *http.Response) (res [][]int16, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response [][]int16 + if err := func() error { + response = make([][]int16, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []int16 + elem = make([]int16, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem int16 + v, err := json.DecodeStringInt16(d) + elemElem = 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 + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if response == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range response { + 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") + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseStringInt16NullableResponse(resp *http.Response) (res NilStringInt16, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response NilStringInt16 + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseStringInt16NullableArrayResponse(resp *http.Response) (res []NilStringInt16, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -40809,9 +41531,150 @@ func decodeTestResponseStringInt16Response(resp *http.Response) (res int16, _ er } d := jx.DecodeBytes(buf) - var response int16 + var response []NilStringInt16 if err := func() error { - v, err := json.DecodeStringInt16(d) + response = make([]NilStringInt16, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NilStringInt16 + if err := elem.Decode(d); err != nil { + return err + } + response = append(response, elem) + return nil + }); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if response == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseStringInt16NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt16, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response [][]NilStringInt16 + if err := func() error { + response = make([][]NilStringInt16, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []NilStringInt16 + elem = make([]NilStringInt16, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem NilStringInt16 + 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 + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if response == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range response { + 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") + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseStringInt32Response(resp *http.Response) (res int32, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response int32 + if err := func() error { + v, err := json.DecodeStringInt32(d) response = v if err != nil { return err @@ -40836,7 +41699,7 @@ func decodeTestResponseStringInt16Response(resp *http.Response) (res int16, _ er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt16ArrayResponse(resp *http.Response) (res []int16, _ error) { +func decodeTestResponseStringInt32ArrayResponse(resp *http.Response) (res []int32, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -40852,12 +41715,12 @@ func decodeTestResponseStringInt16ArrayResponse(resp *http.Response) (res []int1 } d := jx.DecodeBytes(buf) - var response []int16 + var response []int32 if err := func() error { - response = make([]int16, 0) + response = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int16 - v, err := json.DecodeStringInt16(d) + var elem int32 + v, err := json.DecodeStringInt32(d) elem = v if err != nil { return err @@ -40896,7 +41759,7 @@ func decodeTestResponseStringInt16ArrayResponse(resp *http.Response) (res []int1 return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt16ArrayArrayResponse(resp *http.Response) (res [][]int16, _ error) { +func decodeTestResponseStringInt32ArrayArrayResponse(resp *http.Response) (res [][]int32, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -40912,15 +41775,15 @@ func decodeTestResponseStringInt16ArrayArrayResponse(resp *http.Response) (res [ } d := jx.DecodeBytes(buf) - var response [][]int16 + var response [][]int32 if err := func() error { - response = make([][]int16, 0) + response = make([][]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int16 - elem = make([]int16, 0) + var elem []int32 + elem = make([]int32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int16 - v, err := json.DecodeStringInt16(d) + var elemElem int32 + v, err := json.DecodeStringInt32(d) elemElem = v if err != nil { return err @@ -40981,7 +41844,7 @@ func decodeTestResponseStringInt16ArrayArrayResponse(resp *http.Response) (res [ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt16NullableResponse(resp *http.Response) (res NilStringInt16, _ error) { +func decodeTestResponseStringInt32NullableResponse(resp *http.Response) (res NilStringInt32, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -40997,7 +41860,7 @@ func decodeTestResponseStringInt16NullableResponse(resp *http.Response) (res Nil } d := jx.DecodeBytes(buf) - var response NilStringInt16 + var response NilStringInt32 if err := func() error { if err := response.Decode(d); err != nil { return err @@ -41022,7 +41885,7 @@ func decodeTestResponseStringInt16NullableResponse(resp *http.Response) (res Nil return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt16NullableArrayResponse(resp *http.Response) (res []NilStringInt16, _ error) { +func decodeTestResponseStringInt32NullableArrayResponse(resp *http.Response) (res []NilStringInt32, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41038,11 +41901,11 @@ func decodeTestResponseStringInt16NullableArrayResponse(resp *http.Response) (re } d := jx.DecodeBytes(buf) - var response []NilStringInt16 + var response []NilStringInt32 if err := func() error { - response = make([]NilStringInt16, 0) + response = make([]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt16 + var elem NilStringInt32 if err := elem.Decode(d); err != nil { return err } @@ -41080,7 +41943,7 @@ func decodeTestResponseStringInt16NullableArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt16NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt16, _ error) { +func decodeTestResponseStringInt32NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt32, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41096,14 +41959,14 @@ func decodeTestResponseStringInt16NullableArrayArrayResponse(resp *http.Response } d := jx.DecodeBytes(buf) - var response [][]NilStringInt16 + var response [][]NilStringInt32 if err := func() error { - response = make([][]NilStringInt16, 0) + response = make([][]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt16 - elem = make([]NilStringInt16, 0) + var elem []NilStringInt32 + elem = make([]NilStringInt32, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt16 + var elemElem NilStringInt32 if err := elemElem.Decode(d); err != nil { return err } @@ -41163,7 +42026,7 @@ func decodeTestResponseStringInt16NullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt32Response(resp *http.Response) (res int32, _ error) { +func decodeTestResponseStringInt64Response(resp *http.Response) (res int64, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41179,9 +42042,9 @@ func decodeTestResponseStringInt32Response(resp *http.Response) (res int32, _ er } d := jx.DecodeBytes(buf) - var response int32 + var response int64 if err := func() error { - v, err := json.DecodeStringInt32(d) + v, err := json.DecodeStringInt64(d) response = v if err != nil { return err @@ -41206,7 +42069,7 @@ func decodeTestResponseStringInt32Response(resp *http.Response) (res int32, _ er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt32ArrayResponse(resp *http.Response) (res []int32, _ error) { +func decodeTestResponseStringInt64ArrayResponse(resp *http.Response) (res []int64, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41222,12 +42085,12 @@ func decodeTestResponseStringInt32ArrayResponse(resp *http.Response) (res []int3 } d := jx.DecodeBytes(buf) - var response []int32 + var response []int64 if err := func() error { - response = make([]int32, 0) + response = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int32 - v, err := json.DecodeStringInt32(d) + var elem int64 + v, err := json.DecodeStringInt64(d) elem = v if err != nil { return err @@ -41266,7 +42129,7 @@ func decodeTestResponseStringInt32ArrayResponse(resp *http.Response) (res []int3 return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt32ArrayArrayResponse(resp *http.Response) (res [][]int32, _ error) { +func decodeTestResponseStringInt64ArrayArrayResponse(resp *http.Response) (res [][]int64, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41282,15 +42145,15 @@ func decodeTestResponseStringInt32ArrayArrayResponse(resp *http.Response) (res [ } d := jx.DecodeBytes(buf) - var response [][]int32 + var response [][]int64 if err := func() error { - response = make([][]int32, 0) + response = make([][]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int32 - elem = make([]int32, 0) + var elem []int64 + elem = make([]int64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int32 - v, err := json.DecodeStringInt32(d) + var elemElem int64 + v, err := json.DecodeStringInt64(d) elemElem = v if err != nil { return err @@ -41351,7 +42214,7 @@ func decodeTestResponseStringInt32ArrayArrayResponse(resp *http.Response) (res [ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt32NullableResponse(resp *http.Response) (res NilStringInt32, _ error) { +func decodeTestResponseStringInt64NullableResponse(resp *http.Response) (res NilStringInt64, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41367,7 +42230,7 @@ func decodeTestResponseStringInt32NullableResponse(resp *http.Response) (res Nil } d := jx.DecodeBytes(buf) - var response NilStringInt32 + var response NilStringInt64 if err := func() error { if err := response.Decode(d); err != nil { return err @@ -41392,7 +42255,7 @@ func decodeTestResponseStringInt32NullableResponse(resp *http.Response) (res Nil return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt32NullableArrayResponse(resp *http.Response) (res []NilStringInt32, _ error) { +func decodeTestResponseStringInt64NullableArrayResponse(resp *http.Response) (res []NilStringInt64, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41408,11 +42271,11 @@ func decodeTestResponseStringInt32NullableArrayResponse(resp *http.Response) (re } d := jx.DecodeBytes(buf) - var response []NilStringInt32 + var response []NilStringInt64 if err := func() error { - response = make([]NilStringInt32, 0) + response = make([]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt32 + var elem NilStringInt64 if err := elem.Decode(d); err != nil { return err } @@ -41450,7 +42313,7 @@ func decodeTestResponseStringInt32NullableArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt32NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt32, _ error) { +func decodeTestResponseStringInt64NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt64, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41466,14 +42329,14 @@ func decodeTestResponseStringInt32NullableArrayArrayResponse(resp *http.Response } d := jx.DecodeBytes(buf) - var response [][]NilStringInt32 + var response [][]NilStringInt64 if err := func() error { - response = make([][]NilStringInt32, 0) + response = make([][]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt32 - elem = make([]NilStringInt32, 0) + var elem []NilStringInt64 + elem = make([]NilStringInt64, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt32 + var elemElem NilStringInt64 if err := elemElem.Decode(d); err != nil { return err } @@ -41533,7 +42396,7 @@ func decodeTestResponseStringInt32NullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt64Response(resp *http.Response) (res int64, _ error) { +func decodeTestResponseStringInt8Response(resp *http.Response) (res int8, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41549,9 +42412,9 @@ func decodeTestResponseStringInt64Response(resp *http.Response) (res int64, _ er } d := jx.DecodeBytes(buf) - var response int64 + var response int8 if err := func() error { - v, err := json.DecodeStringInt64(d) + v, err := json.DecodeStringInt8(d) response = v if err != nil { return err @@ -41576,7 +42439,7 @@ func decodeTestResponseStringInt64Response(resp *http.Response) (res int64, _ er return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt64ArrayResponse(resp *http.Response) (res []int64, _ error) { +func decodeTestResponseStringInt8ArrayResponse(resp *http.Response) (res []int8, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41592,12 +42455,12 @@ func decodeTestResponseStringInt64ArrayResponse(resp *http.Response) (res []int6 } d := jx.DecodeBytes(buf) - var response []int64 + var response []int8 if err := func() error { - response = make([]int64, 0) + response = make([]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int64 - v, err := json.DecodeStringInt64(d) + var elem int8 + v, err := json.DecodeStringInt8(d) elem = v if err != nil { return err @@ -41636,7 +42499,7 @@ func decodeTestResponseStringInt64ArrayResponse(resp *http.Response) (res []int6 return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt64ArrayArrayResponse(resp *http.Response) (res [][]int64, _ error) { +func decodeTestResponseStringInt8ArrayArrayResponse(resp *http.Response) (res [][]int8, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41652,15 +42515,15 @@ func decodeTestResponseStringInt64ArrayArrayResponse(resp *http.Response) (res [ } d := jx.DecodeBytes(buf) - var response [][]int64 + var response [][]int8 if err := func() error { - response = make([][]int64, 0) + response = make([][]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int64 - elem = make([]int64, 0) + var elem []int8 + elem = make([]int8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int64 - v, err := json.DecodeStringInt64(d) + var elemElem int8 + v, err := json.DecodeStringInt8(d) elemElem = v if err != nil { return err @@ -41721,7 +42584,7 @@ func decodeTestResponseStringInt64ArrayArrayResponse(resp *http.Response) (res [ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt64NullableResponse(resp *http.Response) (res NilStringInt64, _ error) { +func decodeTestResponseStringInt8NullableResponse(resp *http.Response) (res NilStringInt8, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41737,7 +42600,7 @@ func decodeTestResponseStringInt64NullableResponse(resp *http.Response) (res Nil } d := jx.DecodeBytes(buf) - var response NilStringInt64 + var response NilStringInt8 if err := func() error { if err := response.Decode(d); err != nil { return err @@ -41762,7 +42625,7 @@ func decodeTestResponseStringInt64NullableResponse(resp *http.Response) (res Nil return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt64NullableArrayResponse(resp *http.Response) (res []NilStringInt64, _ error) { +func decodeTestResponseStringInt8NullableArrayResponse(resp *http.Response) (res []NilStringInt8, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41778,11 +42641,11 @@ func decodeTestResponseStringInt64NullableArrayResponse(resp *http.Response) (re } d := jx.DecodeBytes(buf) - var response []NilStringInt64 + var response []NilStringInt8 if err := func() error { - response = make([]NilStringInt64, 0) + response = make([]NilStringInt8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt64 + var elem NilStringInt8 if err := elem.Decode(d); err != nil { return err } @@ -41820,7 +42683,7 @@ func decodeTestResponseStringInt64NullableArrayResponse(resp *http.Response) (re return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt64NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt64, _ error) { +func decodeTestResponseStringInt8NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt8, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41836,14 +42699,14 @@ func decodeTestResponseStringInt64NullableArrayArrayResponse(resp *http.Response } d := jx.DecodeBytes(buf) - var response [][]NilStringInt64 + var response [][]NilStringInt8 if err := func() error { - response = make([][]NilStringInt64, 0) + response = make([][]NilStringInt8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt64 - elem = make([]NilStringInt64, 0) + var elem []NilStringInt8 + elem = make([]NilStringInt8, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt64 + var elemElem NilStringInt8 if err := elemElem.Decode(d); err != nil { return err } @@ -41903,50 +42766,7 @@ func decodeTestResponseStringInt64NullableArrayArrayResponse(resp *http.Response return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt8Response(resp *http.Response) (res int8, _ 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": - buf, err := io.ReadAll(resp.Body) - if err != nil { - return res, err - } - d := jx.DecodeBytes(buf) - - var response int8 - if err := func() error { - v, err := json.DecodeStringInt8(d) - response = v - if err != nil { - return err - } - if err := d.Skip(); err != io.EOF { - return errors.New("unexpected trailing data") - } - return nil - }(); err != nil { - err = &ogenerrors.DecodeBodyError{ - ContentType: ct, - Body: buf, - Err: err, - } - return res, err - } - return response, nil - default: - return res, validate.InvalidContentType(ct) - } - } - return res, validate.UnexpectedStatusCode(resp.StatusCode) -} - -func decodeTestResponseStringInt8ArrayResponse(resp *http.Response) (res []int8, _ error) { +func decodeTestResponseStringIntArrayResponse(resp *http.Response) (res []int, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -41962,12 +42782,12 @@ func decodeTestResponseStringInt8ArrayResponse(resp *http.Response) (res []int8, } d := jx.DecodeBytes(buf) - var response []int8 + var response []int if err := func() error { - response = make([]int8, 0) + response = make([]int, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int8 - v, err := json.DecodeStringInt8(d) + var elem int + v, err := json.DecodeStringInt(d) elem = v if err != nil { return err @@ -42006,7 +42826,7 @@ func decodeTestResponseStringInt8ArrayResponse(resp *http.Response) (res []int8, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt8ArrayArrayResponse(resp *http.Response) (res [][]int8, _ error) { +func decodeTestResponseStringIntArrayArrayResponse(resp *http.Response) (res [][]int, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42022,15 +42842,15 @@ func decodeTestResponseStringInt8ArrayArrayResponse(resp *http.Response) (res [] } d := jx.DecodeBytes(buf) - var response [][]int8 + var response [][]int if err := func() error { - response = make([][]int8, 0) + response = make([][]int, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int8 - elem = make([]int8, 0) + var elem []int + elem = make([]int, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int8 - v, err := json.DecodeStringInt8(d) + var elemElem int + v, err := json.DecodeStringInt(d) elemElem = v if err != nil { return err @@ -42091,7 +42911,7 @@ func decodeTestResponseStringInt8ArrayArrayResponse(resp *http.Response) (res [] return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt8NullableResponse(resp *http.Response) (res NilStringInt8, _ error) { +func decodeTestResponseStringIntNullableResponse(resp *http.Response) (res NilStringInt, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42107,7 +42927,7 @@ func decodeTestResponseStringInt8NullableResponse(resp *http.Response) (res NilS } d := jx.DecodeBytes(buf) - var response NilStringInt8 + var response NilStringInt if err := func() error { if err := response.Decode(d); err != nil { return err @@ -42132,7 +42952,7 @@ func decodeTestResponseStringInt8NullableResponse(resp *http.Response) (res NilS return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt8NullableArrayResponse(resp *http.Response) (res []NilStringInt8, _ error) { +func decodeTestResponseStringIntNullableArrayResponse(resp *http.Response) (res []NilStringInt, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42148,11 +42968,11 @@ func decodeTestResponseStringInt8NullableArrayResponse(resp *http.Response) (res } d := jx.DecodeBytes(buf) - var response []NilStringInt8 + var response []NilStringInt if err := func() error { - response = make([]NilStringInt8, 0) + response = make([]NilStringInt, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt8 + var elem NilStringInt if err := elem.Decode(d); err != nil { return err } @@ -42190,7 +43010,7 @@ func decodeTestResponseStringInt8NullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringInt8NullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt8, _ error) { +func decodeTestResponseStringIntNullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42206,14 +43026,14 @@ func decodeTestResponseStringInt8NullableArrayArrayResponse(resp *http.Response) } d := jx.DecodeBytes(buf) - var response [][]NilStringInt8 + var response [][]NilStringInt if err := func() error { - response = make([][]NilStringInt8, 0) + response = make([][]NilStringInt, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt8 - elem = make([]NilStringInt8, 0) + var elem []NilStringInt + elem = make([]NilStringInt, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt8 + var elemElem NilStringInt if err := elemElem.Decode(d); err != nil { return err } @@ -42273,7 +43093,7 @@ func decodeTestResponseStringInt8NullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIntArrayResponse(resp *http.Response) (res []int, _ error) { +func decodeTestResponseStringIpv4Response(resp *http.Response) (res netip.Addr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42289,12 +43109,55 @@ func decodeTestResponseStringIntArrayResponse(resp *http.Response) (res []int, _ } d := jx.DecodeBytes(buf) - var response []int + var response netip.Addr if err := func() error { - response = make([]int, 0) + v, err := json.DecodeIPv4(d) + response = v + if err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + return response, nil + default: + return res, validate.InvalidContentType(ct) + } + } + return res, validate.UnexpectedStatusCode(resp.StatusCode) +} + +func decodeTestResponseStringIpv4ArrayResponse(resp *http.Response) (res []netip.Addr, _ 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": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response []netip.Addr + if err := func() error { + response = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem int - v, err := json.DecodeStringInt(d) + var elem netip.Addr + v, err := json.DecodeIPv4(d) elem = v if err != nil { return err @@ -42333,7 +43196,7 @@ func decodeTestResponseStringIntArrayResponse(resp *http.Response) (res []int, _ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIntArrayArrayResponse(resp *http.Response) (res [][]int, _ error) { +func decodeTestResponseStringIpv4ArrayArrayResponse(resp *http.Response) (res [][]netip.Addr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42349,15 +43212,15 @@ func decodeTestResponseStringIntArrayArrayResponse(resp *http.Response) (res [][ } d := jx.DecodeBytes(buf) - var response [][]int + var response [][]netip.Addr if err := func() error { - response = make([][]int, 0) + response = make([][]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []int - elem = make([]int, 0) + var elem []netip.Addr + elem = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem int - v, err := json.DecodeStringInt(d) + var elemElem netip.Addr + v, err := json.DecodeIPv4(d) elemElem = v if err != nil { return err @@ -42418,7 +43281,7 @@ func decodeTestResponseStringIntArrayArrayResponse(resp *http.Response) (res [][ return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIntNullableResponse(resp *http.Response) (res NilStringInt, _ error) { +func decodeTestResponseStringIpv4NullableResponse(resp *http.Response) (res NilIPv4, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42434,7 +43297,7 @@ func decodeTestResponseStringIntNullableResponse(resp *http.Response) (res NilSt } d := jx.DecodeBytes(buf) - var response NilStringInt + var response NilIPv4 if err := func() error { if err := response.Decode(d); err != nil { return err @@ -42459,7 +43322,7 @@ func decodeTestResponseStringIntNullableResponse(resp *http.Response) (res NilSt return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIntNullableArrayResponse(resp *http.Response) (res []NilStringInt, _ error) { +func decodeTestResponseStringIpv4NullableArrayResponse(resp *http.Response) (res []NilIPv4, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42475,11 +43338,11 @@ func decodeTestResponseStringIntNullableArrayResponse(resp *http.Response) (res } d := jx.DecodeBytes(buf) - var response []NilStringInt + var response []NilIPv4 if err := func() error { - response = make([]NilStringInt, 0) + response = make([]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilStringInt + var elem NilIPv4 if err := elem.Decode(d); err != nil { return err } @@ -42517,7 +43380,7 @@ func decodeTestResponseStringIntNullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIntNullableArrayArrayResponse(resp *http.Response) (res [][]NilStringInt, _ error) { +func decodeTestResponseStringIpv4NullableArrayArrayResponse(resp *http.Response) (res [][]NilIPv4, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42533,14 +43396,14 @@ func decodeTestResponseStringIntNullableArrayArrayResponse(resp *http.Response) } d := jx.DecodeBytes(buf) - var response [][]NilStringInt + var response [][]NilIPv4 if err := func() error { - response = make([][]NilStringInt, 0) + response = make([][]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilStringInt - elem = make([]NilStringInt, 0) + var elem []NilIPv4 + elem = make([]NilIPv4, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilStringInt + var elemElem NilIPv4 if err := elemElem.Decode(d); err != nil { return err } @@ -42600,7 +43463,7 @@ func decodeTestResponseStringIntNullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv4Response(resp *http.Response) (res netip.Addr, _ error) { +func decodeTestResponseStringIpv6Response(resp *http.Response) (res netip.Addr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42618,7 +43481,7 @@ func decodeTestResponseStringIpv4Response(resp *http.Response) (res netip.Addr, var response netip.Addr if err := func() error { - v, err := json.DecodeIPv4(d) + v, err := json.DecodeIPv6(d) response = v if err != nil { return err @@ -42643,7 +43506,7 @@ func decodeTestResponseStringIpv4Response(resp *http.Response) (res netip.Addr, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv4ArrayResponse(resp *http.Response) (res []netip.Addr, _ error) { +func decodeTestResponseStringIpv6ArrayResponse(resp *http.Response) (res []netip.Addr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42664,7 +43527,7 @@ func decodeTestResponseStringIpv4ArrayResponse(resp *http.Response) (res []netip response = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { var elem netip.Addr - v, err := json.DecodeIPv4(d) + v, err := json.DecodeIPv6(d) elem = v if err != nil { return err @@ -42703,7 +43566,7 @@ func decodeTestResponseStringIpv4ArrayResponse(resp *http.Response) (res []netip return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv4ArrayArrayResponse(resp *http.Response) (res [][]netip.Addr, _ error) { +func decodeTestResponseStringIpv6ArrayArrayResponse(resp *http.Response) (res [][]netip.Addr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42727,7 +43590,7 @@ func decodeTestResponseStringIpv4ArrayArrayResponse(resp *http.Response) (res [] elem = make([]netip.Addr, 0) if err := d.Arr(func(d *jx.Decoder) error { var elemElem netip.Addr - v, err := json.DecodeIPv4(d) + v, err := json.DecodeIPv6(d) elemElem = v if err != nil { return err @@ -42788,7 +43651,7 @@ func decodeTestResponseStringIpv4ArrayArrayResponse(resp *http.Response) (res [] return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv4NullableResponse(resp *http.Response) (res NilIPv4, _ error) { +func decodeTestResponseStringIpv6NullableResponse(resp *http.Response) (res NilIPv6, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42804,7 +43667,7 @@ func decodeTestResponseStringIpv4NullableResponse(resp *http.Response) (res NilI } d := jx.DecodeBytes(buf) - var response NilIPv4 + var response NilIPv6 if err := func() error { if err := response.Decode(d); err != nil { return err @@ -42829,7 +43692,7 @@ func decodeTestResponseStringIpv4NullableResponse(resp *http.Response) (res NilI return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv4NullableArrayResponse(resp *http.Response) (res []NilIPv4, _ error) { +func decodeTestResponseStringIpv6NullableArrayResponse(resp *http.Response) (res []NilIPv6, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42845,11 +43708,11 @@ func decodeTestResponseStringIpv4NullableArrayResponse(resp *http.Response) (res } d := jx.DecodeBytes(buf) - var response []NilIPv4 + var response []NilIPv6 if err := func() error { - response = make([]NilIPv4, 0) + response = make([]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIPv4 + var elem NilIPv6 if err := elem.Decode(d); err != nil { return err } @@ -42887,7 +43750,7 @@ func decodeTestResponseStringIpv4NullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv4NullableArrayArrayResponse(resp *http.Response) (res [][]NilIPv4, _ error) { +func decodeTestResponseStringIpv6NullableArrayArrayResponse(resp *http.Response) (res [][]NilIPv6, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42903,14 +43766,14 @@ func decodeTestResponseStringIpv4NullableArrayArrayResponse(resp *http.Response) } d := jx.DecodeBytes(buf) - var response [][]NilIPv4 + var response [][]NilIPv6 if err := func() error { - response = make([][]NilIPv4, 0) + response = make([][]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIPv4 - elem = make([]NilIPv4, 0) + var elem []NilIPv6 + elem = make([]NilIPv6, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIPv4 + var elemElem NilIPv6 if err := elemElem.Decode(d); err != nil { return err } @@ -42970,7 +43833,7 @@ func decodeTestResponseStringIpv4NullableArrayArrayResponse(resp *http.Response) return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv6Response(resp *http.Response) (res netip.Addr, _ error) { +func decodeTestResponseStringMACResponse(resp *http.Response) (res net.HardwareAddr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -42986,9 +43849,9 @@ func decodeTestResponseStringIpv6Response(resp *http.Response) (res netip.Addr, } d := jx.DecodeBytes(buf) - var response netip.Addr + var response net.HardwareAddr if err := func() error { - v, err := json.DecodeIPv6(d) + v, err := json.DecodeMAC(d) response = v if err != nil { return err @@ -43013,7 +43876,7 @@ func decodeTestResponseStringIpv6Response(resp *http.Response) (res netip.Addr, return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv6ArrayResponse(resp *http.Response) (res []netip.Addr, _ error) { +func decodeTestResponseStringMACArrayResponse(resp *http.Response) (res []net.HardwareAddr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -43029,12 +43892,12 @@ func decodeTestResponseStringIpv6ArrayResponse(resp *http.Response) (res []netip } d := jx.DecodeBytes(buf) - var response []netip.Addr + var response []net.HardwareAddr if err := func() error { - response = make([]netip.Addr, 0) + response = make([]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem netip.Addr - v, err := json.DecodeIPv6(d) + var elem net.HardwareAddr + v, err := json.DecodeMAC(d) elem = v if err != nil { return err @@ -43073,7 +43936,7 @@ func decodeTestResponseStringIpv6ArrayResponse(resp *http.Response) (res []netip return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv6ArrayArrayResponse(resp *http.Response) (res [][]netip.Addr, _ error) { +func decodeTestResponseStringMACArrayArrayResponse(resp *http.Response) (res [][]net.HardwareAddr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -43089,15 +43952,15 @@ func decodeTestResponseStringIpv6ArrayArrayResponse(resp *http.Response) (res [] } d := jx.DecodeBytes(buf) - var response [][]netip.Addr + var response [][]net.HardwareAddr if err := func() error { - response = make([][]netip.Addr, 0) + response = make([][]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []netip.Addr - elem = make([]netip.Addr, 0) + var elem []net.HardwareAddr + elem = make([]net.HardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem netip.Addr - v, err := json.DecodeIPv6(d) + var elemElem net.HardwareAddr + v, err := json.DecodeMAC(d) elemElem = v if err != nil { return err @@ -43158,7 +44021,7 @@ func decodeTestResponseStringIpv6ArrayArrayResponse(resp *http.Response) (res [] return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv6NullableResponse(resp *http.Response) (res NilIPv6, _ error) { +func decodeTestResponseStringMACNullableResponse(resp *http.Response) (res NilHardwareAddr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -43174,7 +44037,7 @@ func decodeTestResponseStringIpv6NullableResponse(resp *http.Response) (res NilI } d := jx.DecodeBytes(buf) - var response NilIPv6 + var response NilHardwareAddr if err := func() error { if err := response.Decode(d); err != nil { return err @@ -43199,7 +44062,7 @@ func decodeTestResponseStringIpv6NullableResponse(resp *http.Response) (res NilI return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv6NullableArrayResponse(resp *http.Response) (res []NilIPv6, _ error) { +func decodeTestResponseStringMACNullableArrayResponse(resp *http.Response) (res []NilHardwareAddr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -43215,11 +44078,11 @@ func decodeTestResponseStringIpv6NullableArrayResponse(resp *http.Response) (res } d := jx.DecodeBytes(buf) - var response []NilIPv6 + var response []NilHardwareAddr if err := func() error { - response = make([]NilIPv6, 0) + response = make([]NilHardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NilIPv6 + var elem NilHardwareAddr if err := elem.Decode(d); err != nil { return err } @@ -43257,7 +44120,7 @@ func decodeTestResponseStringIpv6NullableArrayResponse(resp *http.Response) (res return res, validate.UnexpectedStatusCode(resp.StatusCode) } -func decodeTestResponseStringIpv6NullableArrayArrayResponse(resp *http.Response) (res [][]NilIPv6, _ error) { +func decodeTestResponseStringMACNullableArrayArrayResponse(resp *http.Response) (res [][]NilHardwareAddr, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -43273,14 +44136,14 @@ func decodeTestResponseStringIpv6NullableArrayArrayResponse(resp *http.Response) } d := jx.DecodeBytes(buf) - var response [][]NilIPv6 + var response [][]NilHardwareAddr if err := func() error { - response = make([][]NilIPv6, 0) + response = make([][]NilHardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem []NilIPv6 - elem = make([]NilIPv6, 0) + var elem []NilHardwareAddr + elem = make([]NilHardwareAddr, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elemElem NilIPv6 + var elemElem NilHardwareAddr 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 aadece55b..465f812de 100644 --- a/examples/ex_test_format/oas_response_encoders_gen.go +++ b/examples/ex_test_format/oas_response_encoders_gen.go @@ -3,6 +3,7 @@ package api import ( + "net" "net/http" "net/netip" "net/url" @@ -5365,6 +5366,90 @@ func encodeTestRequestRequiredStringIpv6NullableArrayArrayResponse(response *Err return nil } +func encodeTestRequestRequiredStringMACResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestRequiredStringMACArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestRequiredStringMACArrayArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestRequiredStringMACNullableResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestRequiredStringMACNullableArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestRequiredStringMACNullableArrayArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + func encodeTestRequestRequiredStringNullableResponse(response *Error, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json; charset=utf-8") w.WriteHeader(200) @@ -8137,6 +8222,90 @@ func encodeTestRequestStringIpv6NullableArrayArrayResponse(response *Error, w ht return nil } +func encodeTestRequestStringMACResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestStringMACArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestStringMACArrayArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestStringMACNullableResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestStringMACNullableArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestRequestStringMACNullableArrayArrayResponse(response *Error, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + 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; charset=utf-8") w.WriteHeader(200) @@ -13779,6 +13948,114 @@ func encodeTestResponseStringIpv6NullableArrayArrayResponse(response [][]NilIPv6 return nil } +func encodeTestResponseStringMACResponse(response net.HardwareAddr, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + json.EncodeMAC(e, response) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestResponseStringMACArrayResponse(response []net.HardwareAddr, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + e.ArrStart() + for _, elem := range response { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestResponseStringMACArrayArrayResponse(response [][]net.HardwareAddr, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + e.ArrStart() + for _, elem := range response { + e.ArrStart() + for _, elem := range elem { + json.EncodeMAC(e, elem) + } + e.ArrEnd() + } + e.ArrEnd() + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestResponseStringMACNullableResponse(response NilHardwareAddr, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil +} + +func encodeTestResponseStringMACNullableArrayResponse(response []NilHardwareAddr, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + 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 encodeTestResponseStringMACNullableArrayArrayResponse(response [][]NilHardwareAddr, w http.ResponseWriter, span trace.Span) error { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + 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 encodeTestResponseStringNullableResponse(response NilString, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json; charset=utf-8") w.WriteHeader(200) diff --git a/examples/ex_test_format/oas_router_gen.go b/examples/ex_test_format/oas_router_gen.go index ce2bb9527..761b75b2d 100644 --- a/examples/ex_test_format/oas_router_gen.go +++ b/examples/ex_test_format/oas_router_gen.go @@ -9561,6 +9561,151 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { elem = origElem } + elem = origElem + case 'm': // Prefix: "mac" + origElem := elem + if l := len("mac"); len(elem) >= l && elem[0:l] == "mac" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestRequiredStringMACRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + origElem := elem + 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" + origElem := elem + 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.handleTestRequestRequiredStringMACArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestRequestRequiredStringMACArrayArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + + elem = origElem + } + + elem = origElem + case 'n': // Prefix: "nullable" + origElem := elem + 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.handleTestRequestRequiredStringMACNullableRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestRequestRequiredStringMACNullableArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestRequestRequiredStringMACNullableArrayArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + elem = origElem case 'n': // Prefix: "nullable" origElem := elem @@ -14469,6 +14614,151 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { elem = origElem } + elem = origElem + case 'm': // Prefix: "mac" + origElem := elem + if l := len("mac"); len(elem) >= l && elem[0:l] == "mac" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestRequestStringMACRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + origElem := elem + 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" + origElem := elem + 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.handleTestRequestStringMACArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestRequestStringMACArrayArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + + elem = origElem + } + + elem = origElem + case 'n': // Prefix: "nullable" + origElem := elem + 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.handleTestRequestStringMACNullableRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestRequestStringMACNullableArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestRequestStringMACNullableArrayArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + elem = origElem case 'n': // Prefix: "nullable" origElem := elem @@ -22732,6 +23022,151 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { elem = origElem } + elem = origElem + case 'm': // Prefix: "mac" + origElem := elem + if l := len("mac"); len(elem) >= l && elem[0:l] == "mac" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleTestResponseStringMACRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_" + origElem := elem + 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" + origElem := elem + 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.handleTestResponseStringMACArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestResponseStringMACArrayArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + + elem = origElem + } + + elem = origElem + case 'n': // Prefix: "nullable" + origElem := elem + 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.handleTestResponseStringMACNullableRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestResponseStringMACNullableArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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.handleTestResponseStringMACNullableArrayArrayRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + elem = origElem case 'n': // Prefix: "nullable" origElem := elem @@ -36009,6 +36444,175 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { elem = origElem } + elem = origElem + case 'm': // Prefix: "mac" + origElem := elem + if l := len("mac"); len(elem) >= l && elem[0:l] == "mac" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestRequiredStringMAC" + r.summary = "" + r.operationID = "test_request_required_string_mac" + r.pathPattern = "/test_request_required_string_mac" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + origElem := elem + 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" + origElem := elem + 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 = "TestRequestRequiredStringMACArray" + r.summary = "" + r.operationID = "test_request_required_string_mac_array" + r.pathPattern = "/test_request_required_string_mac_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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: TestRequestRequiredStringMACArrayArray + r.name = "TestRequestRequiredStringMACArrayArray" + r.summary = "" + r.operationID = "test_request_required_string_mac_array_array" + r.pathPattern = "/test_request_required_string_mac_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + + elem = origElem + case 'n': // Prefix: "nullable" + origElem := elem + 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 = "TestRequestRequiredStringMACNullable" + r.summary = "" + r.operationID = "test_request_required_string_mac_nullable" + r.pathPattern = "/test_request_required_string_mac_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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 = "TestRequestRequiredStringMACNullableArray" + r.summary = "" + r.operationID = "test_request_required_string_mac_nullable_array" + r.pathPattern = "/test_request_required_string_mac_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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: TestRequestRequiredStringMACNullableArrayArray + r.name = "TestRequestRequiredStringMACNullableArrayArray" + r.summary = "" + r.operationID = "test_request_required_string_mac_nullable_array_array" + r.pathPattern = "/test_request_required_string_mac_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + elem = origElem case 'n': // Prefix: "nullable" origElem := elem @@ -41709,6 +42313,175 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { elem = origElem } + elem = origElem + case 'm': // Prefix: "mac" + origElem := elem + if l := len("mac"); len(elem) >= l && elem[0:l] == "mac" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestRequestStringMAC" + r.summary = "" + r.operationID = "test_request_string_mac" + r.pathPattern = "/test_request_string_mac" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + origElem := elem + 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" + origElem := elem + 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 = "TestRequestStringMACArray" + r.summary = "" + r.operationID = "test_request_string_mac_array" + r.pathPattern = "/test_request_string_mac_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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: TestRequestStringMACArrayArray + r.name = "TestRequestStringMACArrayArray" + r.summary = "" + r.operationID = "test_request_string_mac_array_array" + r.pathPattern = "/test_request_string_mac_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + + elem = origElem + case 'n': // Prefix: "nullable" + origElem := elem + 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 = "TestRequestStringMACNullable" + r.summary = "" + r.operationID = "test_request_string_mac_nullable" + r.pathPattern = "/test_request_string_mac_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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 = "TestRequestStringMACNullableArray" + r.summary = "" + r.operationID = "test_request_string_mac_nullable_array" + r.pathPattern = "/test_request_string_mac_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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: TestRequestStringMACNullableArrayArray + r.name = "TestRequestStringMACNullableArrayArray" + r.summary = "" + r.operationID = "test_request_string_mac_nullable_array_array" + r.pathPattern = "/test_request_string_mac_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + elem = origElem case 'n': // Prefix: "nullable" origElem := elem @@ -51304,6 +52077,175 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { elem = origElem } + elem = origElem + case 'm': // Prefix: "mac" + origElem := elem + if l := len("mac"); len(elem) >= l && elem[0:l] == "mac" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = "TestResponseStringMAC" + r.summary = "" + r.operationID = "test_response_string_mac" + r.pathPattern = "/test_response_string_mac" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_" + origElem := elem + 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" + origElem := elem + 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 = "TestResponseStringMACArray" + r.summary = "" + r.operationID = "test_response_string_mac_array" + r.pathPattern = "/test_response_string_mac_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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: TestResponseStringMACArrayArray + r.name = "TestResponseStringMACArrayArray" + r.summary = "" + r.operationID = "test_response_string_mac_array_array" + r.pathPattern = "/test_response_string_mac_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + + elem = origElem + case 'n': // Prefix: "nullable" + origElem := elem + 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 = "TestResponseStringMACNullable" + r.summary = "" + r.operationID = "test_response_string_mac_nullable" + r.pathPattern = "/test_response_string_mac_nullable" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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 = "TestResponseStringMACNullableArray" + r.summary = "" + r.operationID = "test_response_string_mac_nullable_array" + r.pathPattern = "/test_response_string_mac_nullable_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case '_': // Prefix: "_array" + origElem := elem + 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: TestResponseStringMACNullableArrayArray + r.name = "TestResponseStringMACNullableArrayArray" + r.summary = "" + r.operationID = "test_response_string_mac_nullable_array_array" + r.pathPattern = "/test_response_string_mac_nullable_array_array" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + + elem = origElem + } + elem = origElem case 'n': // Prefix: "nullable" origElem := elem diff --git a/examples/ex_test_format/oas_schemas_gen.go b/examples/ex_test_format/oas_schemas_gen.go index 19e1bdf32..dfc325aa0 100644 --- a/examples/ex_test_format/oas_schemas_gen.go +++ b/examples/ex_test_format/oas_schemas_gen.go @@ -3,6 +3,7 @@ package api import ( + "net" "net/netip" "net/url" "time" @@ -307,6 +308,51 @@ func (o NilFloat64) Or(d float64) float64 { return d } +// NewNilHardwareAddr returns new NilHardwareAddr with value set to v. +func NewNilHardwareAddr(v net.HardwareAddr) NilHardwareAddr { + return NilHardwareAddr{ + Value: v, + } +} + +// NilHardwareAddr is nullable net.HardwareAddr. +type NilHardwareAddr struct { + Value net.HardwareAddr + Null bool +} + +// SetTo sets value to v. +func (o *NilHardwareAddr) SetTo(v net.HardwareAddr) { + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o NilHardwareAddr) IsNull() bool { return o.Null } + +// SetNull sets value to null. +func (o *NilHardwareAddr) SetToNull() { + o.Null = true + var v net.HardwareAddr + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o NilHardwareAddr) Get() (v net.HardwareAddr, 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 NilHardwareAddr) Or(d net.HardwareAddr) net.HardwareAddr { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewNilIP returns new NilIP with value set to v. func NewNilIP(v netip.Addr) NilIP { return NilIP{ @@ -2248,6 +2294,52 @@ func (o OptFloat64) Or(d float64) float64 { return d } +// NewOptHardwareAddr returns new OptHardwareAddr with value set to v. +func NewOptHardwareAddr(v net.HardwareAddr) OptHardwareAddr { + return OptHardwareAddr{ + Value: v, + Set: true, + } +} + +// OptHardwareAddr is optional net.HardwareAddr. +type OptHardwareAddr struct { + Value net.HardwareAddr + Set bool +} + +// IsSet returns true if OptHardwareAddr was set. +func (o OptHardwareAddr) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptHardwareAddr) Reset() { + var v net.HardwareAddr + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptHardwareAddr) SetTo(v net.HardwareAddr) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptHardwareAddr) Get() (v net.HardwareAddr, 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 OptHardwareAddr) Or(d net.HardwareAddr) net.HardwareAddr { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptIP returns new OptIP with value set to v. func NewOptIP(v netip.Addr) OptIP { return OptIP{ @@ -3057,6 +3149,69 @@ func (o OptNilFloat64) Or(d float64) float64 { return d } +// NewOptNilHardwareAddr returns new OptNilHardwareAddr with value set to v. +func NewOptNilHardwareAddr(v net.HardwareAddr) OptNilHardwareAddr { + return OptNilHardwareAddr{ + Value: v, + Set: true, + } +} + +// OptNilHardwareAddr is optional nullable net.HardwareAddr. +type OptNilHardwareAddr struct { + Value net.HardwareAddr + Set bool + Null bool +} + +// IsSet returns true if OptNilHardwareAddr was set. +func (o OptNilHardwareAddr) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptNilHardwareAddr) Reset() { + var v net.HardwareAddr + o.Value = v + o.Set = false + o.Null = false +} + +// SetTo sets value to v. +func (o *OptNilHardwareAddr) SetTo(v net.HardwareAddr) { + o.Set = true + o.Null = false + o.Value = v +} + +// IsSet returns true if value is Null. +func (o OptNilHardwareAddr) IsNull() bool { return o.Null } + +// SetNull sets value to null. +func (o *OptNilHardwareAddr) SetToNull() { + o.Set = true + o.Null = true + var v net.HardwareAddr + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptNilHardwareAddr) Get() (v net.HardwareAddr, 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 OptNilHardwareAddr) Or(d net.HardwareAddr) net.HardwareAddr { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptNilIP returns new OptNilIP with value set to v. func NewOptNilIP(v netip.Addr) OptNilIP { return OptNilIP{ @@ -6860,6 +7015,7 @@ type TestRequestFormatTestReq struct { RequiredArrayStringIP []netip.Addr `json:"required_array_string_ip"` RequiredArrayStringIpv4 []netip.Addr `json:"required_array_string_ipv4"` RequiredArrayStringIpv6 []netip.Addr `json:"required_array_string_ipv6"` + RequiredArrayStringMAC []net.HardwareAddr `json:"required_array_string_mac"` RequiredArrayStringPassword []string `json:"required_array_string_password"` RequiredArrayStringTime []time.Time `json:"required_array_string_time"` RequiredArrayStringUint []uint `json:"required_array_string_uint"` @@ -6917,6 +7073,7 @@ type TestRequestFormatTestReq struct { RequiredDoubleArrayStringIP [][]netip.Addr `json:"required_double_array_string_ip"` RequiredDoubleArrayStringIpv4 [][]netip.Addr `json:"required_double_array_string_ipv4"` RequiredDoubleArrayStringIpv6 [][]netip.Addr `json:"required_double_array_string_ipv6"` + RequiredDoubleArrayStringMAC [][]net.HardwareAddr `json:"required_double_array_string_mac"` RequiredDoubleArrayStringPassword [][]string `json:"required_double_array_string_password"` RequiredDoubleArrayStringTime [][]time.Time `json:"required_double_array_string_time"` RequiredDoubleArrayStringUint [][]uint `json:"required_double_array_string_uint"` @@ -6971,6 +7128,7 @@ type TestRequestFormatTestReq struct { RequiredStringIP netip.Addr `json:"required_string_ip"` RequiredStringIpv4 netip.Addr `json:"required_string_ipv4"` RequiredStringIpv6 netip.Addr `json:"required_string_ipv6"` + RequiredStringMAC net.HardwareAddr `json:"required_string_mac"` RequiredStringPassword string `json:"required_string_password"` RequiredStringTime time.Time `json:"required_string_time"` RequiredStringUint uint `json:"required_string_uint"` @@ -7028,6 +7186,7 @@ type TestRequestFormatTestReq struct { OptionalArrayStringIP []netip.Addr `json:"optional_array_string_ip"` OptionalArrayStringIpv4 []netip.Addr `json:"optional_array_string_ipv4"` OptionalArrayStringIpv6 []netip.Addr `json:"optional_array_string_ipv6"` + OptionalArrayStringMAC []net.HardwareAddr `json:"optional_array_string_mac"` OptionalArrayStringPassword []string `json:"optional_array_string_password"` OptionalArrayStringTime []time.Time `json:"optional_array_string_time"` OptionalArrayStringUint []uint `json:"optional_array_string_uint"` @@ -7085,6 +7244,7 @@ type TestRequestFormatTestReq struct { OptionalDoubleArrayStringIP [][]netip.Addr `json:"optional_double_array_string_ip"` OptionalDoubleArrayStringIpv4 [][]netip.Addr `json:"optional_double_array_string_ipv4"` OptionalDoubleArrayStringIpv6 [][]netip.Addr `json:"optional_double_array_string_ipv6"` + OptionalDoubleArrayStringMAC [][]net.HardwareAddr `json:"optional_double_array_string_mac"` OptionalDoubleArrayStringPassword [][]string `json:"optional_double_array_string_password"` OptionalDoubleArrayStringTime [][]time.Time `json:"optional_double_array_string_time"` OptionalDoubleArrayStringUint [][]uint `json:"optional_double_array_string_uint"` @@ -7139,6 +7299,7 @@ type TestRequestFormatTestReq struct { OptionalStringIP OptIP `json:"optional_string_ip"` OptionalStringIpv4 OptIPv4 `json:"optional_string_ipv4"` OptionalStringIpv6 OptIPv6 `json:"optional_string_ipv6"` + OptionalStringMAC OptHardwareAddr `json:"optional_string_mac"` OptionalStringPassword OptString `json:"optional_string_password"` OptionalStringTime OptTime `json:"optional_string_time"` OptionalStringUint OptStringUint `json:"optional_string_uint"` @@ -7370,6 +7531,11 @@ func (s *TestRequestFormatTestReq) GetRequiredArrayStringIpv6() []netip.Addr { return s.RequiredArrayStringIpv6 } +// GetRequiredArrayStringMAC returns the value of RequiredArrayStringMAC. +func (s *TestRequestFormatTestReq) GetRequiredArrayStringMAC() []net.HardwareAddr { + return s.RequiredArrayStringMAC +} + // GetRequiredArrayStringPassword returns the value of RequiredArrayStringPassword. func (s *TestRequestFormatTestReq) GetRequiredArrayStringPassword() []string { return s.RequiredArrayStringPassword @@ -7655,6 +7821,11 @@ func (s *TestRequestFormatTestReq) GetRequiredDoubleArrayStringIpv6() [][]netip. return s.RequiredDoubleArrayStringIpv6 } +// GetRequiredDoubleArrayStringMAC returns the value of RequiredDoubleArrayStringMAC. +func (s *TestRequestFormatTestReq) GetRequiredDoubleArrayStringMAC() [][]net.HardwareAddr { + return s.RequiredDoubleArrayStringMAC +} + // GetRequiredDoubleArrayStringPassword returns the value of RequiredDoubleArrayStringPassword. func (s *TestRequestFormatTestReq) GetRequiredDoubleArrayStringPassword() [][]string { return s.RequiredDoubleArrayStringPassword @@ -7925,6 +8096,11 @@ func (s *TestRequestFormatTestReq) GetRequiredStringIpv6() netip.Addr { return s.RequiredStringIpv6 } +// GetRequiredStringMAC returns the value of RequiredStringMAC. +func (s *TestRequestFormatTestReq) GetRequiredStringMAC() net.HardwareAddr { + return s.RequiredStringMAC +} + // GetRequiredStringPassword returns the value of RequiredStringPassword. func (s *TestRequestFormatTestReq) GetRequiredStringPassword() string { return s.RequiredStringPassword @@ -8210,6 +8386,11 @@ func (s *TestRequestFormatTestReq) GetOptionalArrayStringIpv6() []netip.Addr { return s.OptionalArrayStringIpv6 } +// GetOptionalArrayStringMAC returns the value of OptionalArrayStringMAC. +func (s *TestRequestFormatTestReq) GetOptionalArrayStringMAC() []net.HardwareAddr { + return s.OptionalArrayStringMAC +} + // GetOptionalArrayStringPassword returns the value of OptionalArrayStringPassword. func (s *TestRequestFormatTestReq) GetOptionalArrayStringPassword() []string { return s.OptionalArrayStringPassword @@ -8495,6 +8676,11 @@ func (s *TestRequestFormatTestReq) GetOptionalDoubleArrayStringIpv6() [][]netip. return s.OptionalDoubleArrayStringIpv6 } +// GetOptionalDoubleArrayStringMAC returns the value of OptionalDoubleArrayStringMAC. +func (s *TestRequestFormatTestReq) GetOptionalDoubleArrayStringMAC() [][]net.HardwareAddr { + return s.OptionalDoubleArrayStringMAC +} + // GetOptionalDoubleArrayStringPassword returns the value of OptionalDoubleArrayStringPassword. func (s *TestRequestFormatTestReq) GetOptionalDoubleArrayStringPassword() [][]string { return s.OptionalDoubleArrayStringPassword @@ -8765,6 +8951,11 @@ func (s *TestRequestFormatTestReq) GetOptionalStringIpv6() OptIPv6 { return s.OptionalStringIpv6 } +// GetOptionalStringMAC returns the value of OptionalStringMAC. +func (s *TestRequestFormatTestReq) GetOptionalStringMAC() OptHardwareAddr { + return s.OptionalStringMAC +} + // GetOptionalStringPassword returns the value of OptionalStringPassword. func (s *TestRequestFormatTestReq) GetOptionalStringPassword() OptString { return s.OptionalStringPassword @@ -9050,6 +9241,11 @@ func (s *TestRequestFormatTestReq) SetRequiredArrayStringIpv6(val []netip.Addr) s.RequiredArrayStringIpv6 = val } +// SetRequiredArrayStringMAC sets the value of RequiredArrayStringMAC. +func (s *TestRequestFormatTestReq) SetRequiredArrayStringMAC(val []net.HardwareAddr) { + s.RequiredArrayStringMAC = val +} + // SetRequiredArrayStringPassword sets the value of RequiredArrayStringPassword. func (s *TestRequestFormatTestReq) SetRequiredArrayStringPassword(val []string) { s.RequiredArrayStringPassword = val @@ -9335,6 +9531,11 @@ func (s *TestRequestFormatTestReq) SetRequiredDoubleArrayStringIpv6(val [][]neti s.RequiredDoubleArrayStringIpv6 = val } +// SetRequiredDoubleArrayStringMAC sets the value of RequiredDoubleArrayStringMAC. +func (s *TestRequestFormatTestReq) SetRequiredDoubleArrayStringMAC(val [][]net.HardwareAddr) { + s.RequiredDoubleArrayStringMAC = val +} + // SetRequiredDoubleArrayStringPassword sets the value of RequiredDoubleArrayStringPassword. func (s *TestRequestFormatTestReq) SetRequiredDoubleArrayStringPassword(val [][]string) { s.RequiredDoubleArrayStringPassword = val @@ -9605,6 +9806,11 @@ func (s *TestRequestFormatTestReq) SetRequiredStringIpv6(val netip.Addr) { s.RequiredStringIpv6 = val } +// SetRequiredStringMAC sets the value of RequiredStringMAC. +func (s *TestRequestFormatTestReq) SetRequiredStringMAC(val net.HardwareAddr) { + s.RequiredStringMAC = val +} + // SetRequiredStringPassword sets the value of RequiredStringPassword. func (s *TestRequestFormatTestReq) SetRequiredStringPassword(val string) { s.RequiredStringPassword = val @@ -9890,6 +10096,11 @@ func (s *TestRequestFormatTestReq) SetOptionalArrayStringIpv6(val []netip.Addr) s.OptionalArrayStringIpv6 = val } +// SetOptionalArrayStringMAC sets the value of OptionalArrayStringMAC. +func (s *TestRequestFormatTestReq) SetOptionalArrayStringMAC(val []net.HardwareAddr) { + s.OptionalArrayStringMAC = val +} + // SetOptionalArrayStringPassword sets the value of OptionalArrayStringPassword. func (s *TestRequestFormatTestReq) SetOptionalArrayStringPassword(val []string) { s.OptionalArrayStringPassword = val @@ -10175,6 +10386,11 @@ func (s *TestRequestFormatTestReq) SetOptionalDoubleArrayStringIpv6(val [][]neti s.OptionalDoubleArrayStringIpv6 = val } +// SetOptionalDoubleArrayStringMAC sets the value of OptionalDoubleArrayStringMAC. +func (s *TestRequestFormatTestReq) SetOptionalDoubleArrayStringMAC(val [][]net.HardwareAddr) { + s.OptionalDoubleArrayStringMAC = val +} + // SetOptionalDoubleArrayStringPassword sets the value of OptionalDoubleArrayStringPassword. func (s *TestRequestFormatTestReq) SetOptionalDoubleArrayStringPassword(val [][]string) { s.OptionalDoubleArrayStringPassword = val @@ -10445,6 +10661,11 @@ func (s *TestRequestFormatTestReq) SetOptionalStringIpv6(val OptIPv6) { s.OptionalStringIpv6 = val } +// SetOptionalStringMAC sets the value of OptionalStringMAC. +func (s *TestRequestFormatTestReq) SetOptionalStringMAC(val OptHardwareAddr) { + s.OptionalStringMAC = val +} + // SetOptionalStringPassword sets the value of OptionalStringPassword. func (s *TestRequestFormatTestReq) SetOptionalStringPassword(val OptString) { s.OptionalStringPassword = val @@ -10561,6 +10782,7 @@ type TestRequestRequiredFormatTestReq struct { RequiredArrayStringIP []netip.Addr `json:"required_array_string_ip"` RequiredArrayStringIpv4 []netip.Addr `json:"required_array_string_ipv4"` RequiredArrayStringIpv6 []netip.Addr `json:"required_array_string_ipv6"` + RequiredArrayStringMAC []net.HardwareAddr `json:"required_array_string_mac"` RequiredArrayStringPassword []string `json:"required_array_string_password"` RequiredArrayStringTime []time.Time `json:"required_array_string_time"` RequiredArrayStringUint []uint `json:"required_array_string_uint"` @@ -10618,6 +10840,7 @@ type TestRequestRequiredFormatTestReq struct { RequiredDoubleArrayStringIP [][]netip.Addr `json:"required_double_array_string_ip"` RequiredDoubleArrayStringIpv4 [][]netip.Addr `json:"required_double_array_string_ipv4"` RequiredDoubleArrayStringIpv6 [][]netip.Addr `json:"required_double_array_string_ipv6"` + RequiredDoubleArrayStringMAC [][]net.HardwareAddr `json:"required_double_array_string_mac"` RequiredDoubleArrayStringPassword [][]string `json:"required_double_array_string_password"` RequiredDoubleArrayStringTime [][]time.Time `json:"required_double_array_string_time"` RequiredDoubleArrayStringUint [][]uint `json:"required_double_array_string_uint"` @@ -10672,6 +10895,7 @@ type TestRequestRequiredFormatTestReq struct { RequiredStringIP netip.Addr `json:"required_string_ip"` RequiredStringIpv4 netip.Addr `json:"required_string_ipv4"` RequiredStringIpv6 netip.Addr `json:"required_string_ipv6"` + RequiredStringMAC net.HardwareAddr `json:"required_string_mac"` RequiredStringPassword string `json:"required_string_password"` RequiredStringTime time.Time `json:"required_string_time"` RequiredStringUint uint `json:"required_string_uint"` @@ -10729,6 +10953,7 @@ type TestRequestRequiredFormatTestReq struct { OptionalArrayStringIP []netip.Addr `json:"optional_array_string_ip"` OptionalArrayStringIpv4 []netip.Addr `json:"optional_array_string_ipv4"` OptionalArrayStringIpv6 []netip.Addr `json:"optional_array_string_ipv6"` + OptionalArrayStringMAC []net.HardwareAddr `json:"optional_array_string_mac"` OptionalArrayStringPassword []string `json:"optional_array_string_password"` OptionalArrayStringTime []time.Time `json:"optional_array_string_time"` OptionalArrayStringUint []uint `json:"optional_array_string_uint"` @@ -10786,6 +11011,7 @@ type TestRequestRequiredFormatTestReq struct { OptionalDoubleArrayStringIP [][]netip.Addr `json:"optional_double_array_string_ip"` OptionalDoubleArrayStringIpv4 [][]netip.Addr `json:"optional_double_array_string_ipv4"` OptionalDoubleArrayStringIpv6 [][]netip.Addr `json:"optional_double_array_string_ipv6"` + OptionalDoubleArrayStringMAC [][]net.HardwareAddr `json:"optional_double_array_string_mac"` OptionalDoubleArrayStringPassword [][]string `json:"optional_double_array_string_password"` OptionalDoubleArrayStringTime [][]time.Time `json:"optional_double_array_string_time"` OptionalDoubleArrayStringUint [][]uint `json:"optional_double_array_string_uint"` @@ -10840,6 +11066,7 @@ type TestRequestRequiredFormatTestReq struct { OptionalStringIP OptIP `json:"optional_string_ip"` OptionalStringIpv4 OptIPv4 `json:"optional_string_ipv4"` OptionalStringIpv6 OptIPv6 `json:"optional_string_ipv6"` + OptionalStringMAC OptHardwareAddr `json:"optional_string_mac"` OptionalStringPassword OptString `json:"optional_string_password"` OptionalStringTime OptTime `json:"optional_string_time"` OptionalStringUint OptStringUint `json:"optional_string_uint"` @@ -11071,6 +11298,11 @@ func (s *TestRequestRequiredFormatTestReq) GetRequiredArrayStringIpv6() []netip. return s.RequiredArrayStringIpv6 } +// GetRequiredArrayStringMAC returns the value of RequiredArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) GetRequiredArrayStringMAC() []net.HardwareAddr { + return s.RequiredArrayStringMAC +} + // GetRequiredArrayStringPassword returns the value of RequiredArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) GetRequiredArrayStringPassword() []string { return s.RequiredArrayStringPassword @@ -11356,6 +11588,11 @@ func (s *TestRequestRequiredFormatTestReq) GetRequiredDoubleArrayStringIpv6() [] return s.RequiredDoubleArrayStringIpv6 } +// GetRequiredDoubleArrayStringMAC returns the value of RequiredDoubleArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) GetRequiredDoubleArrayStringMAC() [][]net.HardwareAddr { + return s.RequiredDoubleArrayStringMAC +} + // GetRequiredDoubleArrayStringPassword returns the value of RequiredDoubleArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) GetRequiredDoubleArrayStringPassword() [][]string { return s.RequiredDoubleArrayStringPassword @@ -11626,6 +11863,11 @@ func (s *TestRequestRequiredFormatTestReq) GetRequiredStringIpv6() netip.Addr { return s.RequiredStringIpv6 } +// GetRequiredStringMAC returns the value of RequiredStringMAC. +func (s *TestRequestRequiredFormatTestReq) GetRequiredStringMAC() net.HardwareAddr { + return s.RequiredStringMAC +} + // GetRequiredStringPassword returns the value of RequiredStringPassword. func (s *TestRequestRequiredFormatTestReq) GetRequiredStringPassword() string { return s.RequiredStringPassword @@ -11911,6 +12153,11 @@ func (s *TestRequestRequiredFormatTestReq) GetOptionalArrayStringIpv6() []netip. return s.OptionalArrayStringIpv6 } +// GetOptionalArrayStringMAC returns the value of OptionalArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) GetOptionalArrayStringMAC() []net.HardwareAddr { + return s.OptionalArrayStringMAC +} + // GetOptionalArrayStringPassword returns the value of OptionalArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) GetOptionalArrayStringPassword() []string { return s.OptionalArrayStringPassword @@ -12196,6 +12443,11 @@ func (s *TestRequestRequiredFormatTestReq) GetOptionalDoubleArrayStringIpv6() [] return s.OptionalDoubleArrayStringIpv6 } +// GetOptionalDoubleArrayStringMAC returns the value of OptionalDoubleArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) GetOptionalDoubleArrayStringMAC() [][]net.HardwareAddr { + return s.OptionalDoubleArrayStringMAC +} + // GetOptionalDoubleArrayStringPassword returns the value of OptionalDoubleArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) GetOptionalDoubleArrayStringPassword() [][]string { return s.OptionalDoubleArrayStringPassword @@ -12466,6 +12718,11 @@ func (s *TestRequestRequiredFormatTestReq) GetOptionalStringIpv6() OptIPv6 { return s.OptionalStringIpv6 } +// GetOptionalStringMAC returns the value of OptionalStringMAC. +func (s *TestRequestRequiredFormatTestReq) GetOptionalStringMAC() OptHardwareAddr { + return s.OptionalStringMAC +} + // GetOptionalStringPassword returns the value of OptionalStringPassword. func (s *TestRequestRequiredFormatTestReq) GetOptionalStringPassword() OptString { return s.OptionalStringPassword @@ -12751,6 +13008,11 @@ func (s *TestRequestRequiredFormatTestReq) SetRequiredArrayStringIpv6(val []neti s.RequiredArrayStringIpv6 = val } +// SetRequiredArrayStringMAC sets the value of RequiredArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) SetRequiredArrayStringMAC(val []net.HardwareAddr) { + s.RequiredArrayStringMAC = val +} + // SetRequiredArrayStringPassword sets the value of RequiredArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) SetRequiredArrayStringPassword(val []string) { s.RequiredArrayStringPassword = val @@ -13036,6 +13298,11 @@ func (s *TestRequestRequiredFormatTestReq) SetRequiredDoubleArrayStringIpv6(val s.RequiredDoubleArrayStringIpv6 = val } +// SetRequiredDoubleArrayStringMAC sets the value of RequiredDoubleArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) SetRequiredDoubleArrayStringMAC(val [][]net.HardwareAddr) { + s.RequiredDoubleArrayStringMAC = val +} + // SetRequiredDoubleArrayStringPassword sets the value of RequiredDoubleArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) SetRequiredDoubleArrayStringPassword(val [][]string) { s.RequiredDoubleArrayStringPassword = val @@ -13306,6 +13573,11 @@ func (s *TestRequestRequiredFormatTestReq) SetRequiredStringIpv6(val netip.Addr) s.RequiredStringIpv6 = val } +// SetRequiredStringMAC sets the value of RequiredStringMAC. +func (s *TestRequestRequiredFormatTestReq) SetRequiredStringMAC(val net.HardwareAddr) { + s.RequiredStringMAC = val +} + // SetRequiredStringPassword sets the value of RequiredStringPassword. func (s *TestRequestRequiredFormatTestReq) SetRequiredStringPassword(val string) { s.RequiredStringPassword = val @@ -13591,6 +13863,11 @@ func (s *TestRequestRequiredFormatTestReq) SetOptionalArrayStringIpv6(val []neti s.OptionalArrayStringIpv6 = val } +// SetOptionalArrayStringMAC sets the value of OptionalArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) SetOptionalArrayStringMAC(val []net.HardwareAddr) { + s.OptionalArrayStringMAC = val +} + // SetOptionalArrayStringPassword sets the value of OptionalArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) SetOptionalArrayStringPassword(val []string) { s.OptionalArrayStringPassword = val @@ -13876,6 +14153,11 @@ func (s *TestRequestRequiredFormatTestReq) SetOptionalDoubleArrayStringIpv6(val s.OptionalDoubleArrayStringIpv6 = val } +// SetOptionalDoubleArrayStringMAC sets the value of OptionalDoubleArrayStringMAC. +func (s *TestRequestRequiredFormatTestReq) SetOptionalDoubleArrayStringMAC(val [][]net.HardwareAddr) { + s.OptionalDoubleArrayStringMAC = val +} + // SetOptionalDoubleArrayStringPassword sets the value of OptionalDoubleArrayStringPassword. func (s *TestRequestRequiredFormatTestReq) SetOptionalDoubleArrayStringPassword(val [][]string) { s.OptionalDoubleArrayStringPassword = val @@ -14146,6 +14428,11 @@ func (s *TestRequestRequiredFormatTestReq) SetOptionalStringIpv6(val OptIPv6) { s.OptionalStringIpv6 = val } +// SetOptionalStringMAC sets the value of OptionalStringMAC. +func (s *TestRequestRequiredFormatTestReq) SetOptionalStringMAC(val OptHardwareAddr) { + s.OptionalStringMAC = val +} + // SetOptionalStringPassword sets the value of OptionalStringPassword. func (s *TestRequestRequiredFormatTestReq) SetOptionalStringPassword(val OptString) { s.OptionalStringPassword = val @@ -14262,6 +14549,7 @@ type TestResponseFormatTestOK struct { RequiredArrayStringIP []netip.Addr `json:"required_array_string_ip"` RequiredArrayStringIpv4 []netip.Addr `json:"required_array_string_ipv4"` RequiredArrayStringIpv6 []netip.Addr `json:"required_array_string_ipv6"` + RequiredArrayStringMAC []net.HardwareAddr `json:"required_array_string_mac"` RequiredArrayStringPassword []string `json:"required_array_string_password"` RequiredArrayStringTime []time.Time `json:"required_array_string_time"` RequiredArrayStringUint []uint `json:"required_array_string_uint"` @@ -14319,6 +14607,7 @@ type TestResponseFormatTestOK struct { RequiredDoubleArrayStringIP [][]netip.Addr `json:"required_double_array_string_ip"` RequiredDoubleArrayStringIpv4 [][]netip.Addr `json:"required_double_array_string_ipv4"` RequiredDoubleArrayStringIpv6 [][]netip.Addr `json:"required_double_array_string_ipv6"` + RequiredDoubleArrayStringMAC [][]net.HardwareAddr `json:"required_double_array_string_mac"` RequiredDoubleArrayStringPassword [][]string `json:"required_double_array_string_password"` RequiredDoubleArrayStringTime [][]time.Time `json:"required_double_array_string_time"` RequiredDoubleArrayStringUint [][]uint `json:"required_double_array_string_uint"` @@ -14373,6 +14662,7 @@ type TestResponseFormatTestOK struct { RequiredStringIP netip.Addr `json:"required_string_ip"` RequiredStringIpv4 netip.Addr `json:"required_string_ipv4"` RequiredStringIpv6 netip.Addr `json:"required_string_ipv6"` + RequiredStringMAC net.HardwareAddr `json:"required_string_mac"` RequiredStringPassword string `json:"required_string_password"` RequiredStringTime time.Time `json:"required_string_time"` RequiredStringUint uint `json:"required_string_uint"` @@ -14430,6 +14720,7 @@ type TestResponseFormatTestOK struct { OptionalArrayStringIP []netip.Addr `json:"optional_array_string_ip"` OptionalArrayStringIpv4 []netip.Addr `json:"optional_array_string_ipv4"` OptionalArrayStringIpv6 []netip.Addr `json:"optional_array_string_ipv6"` + OptionalArrayStringMAC []net.HardwareAddr `json:"optional_array_string_mac"` OptionalArrayStringPassword []string `json:"optional_array_string_password"` OptionalArrayStringTime []time.Time `json:"optional_array_string_time"` OptionalArrayStringUint []uint `json:"optional_array_string_uint"` @@ -14487,6 +14778,7 @@ type TestResponseFormatTestOK struct { OptionalDoubleArrayStringIP [][]netip.Addr `json:"optional_double_array_string_ip"` OptionalDoubleArrayStringIpv4 [][]netip.Addr `json:"optional_double_array_string_ipv4"` OptionalDoubleArrayStringIpv6 [][]netip.Addr `json:"optional_double_array_string_ipv6"` + OptionalDoubleArrayStringMAC [][]net.HardwareAddr `json:"optional_double_array_string_mac"` OptionalDoubleArrayStringPassword [][]string `json:"optional_double_array_string_password"` OptionalDoubleArrayStringTime [][]time.Time `json:"optional_double_array_string_time"` OptionalDoubleArrayStringUint [][]uint `json:"optional_double_array_string_uint"` @@ -14541,6 +14833,7 @@ type TestResponseFormatTestOK struct { OptionalStringIP OptIP `json:"optional_string_ip"` OptionalStringIpv4 OptIPv4 `json:"optional_string_ipv4"` OptionalStringIpv6 OptIPv6 `json:"optional_string_ipv6"` + OptionalStringMAC OptHardwareAddr `json:"optional_string_mac"` OptionalStringPassword OptString `json:"optional_string_password"` OptionalStringTime OptTime `json:"optional_string_time"` OptionalStringUint OptStringUint `json:"optional_string_uint"` @@ -14772,6 +15065,11 @@ func (s *TestResponseFormatTestOK) GetRequiredArrayStringIpv6() []netip.Addr { return s.RequiredArrayStringIpv6 } +// GetRequiredArrayStringMAC returns the value of RequiredArrayStringMAC. +func (s *TestResponseFormatTestOK) GetRequiredArrayStringMAC() []net.HardwareAddr { + return s.RequiredArrayStringMAC +} + // GetRequiredArrayStringPassword returns the value of RequiredArrayStringPassword. func (s *TestResponseFormatTestOK) GetRequiredArrayStringPassword() []string { return s.RequiredArrayStringPassword @@ -15057,6 +15355,11 @@ func (s *TestResponseFormatTestOK) GetRequiredDoubleArrayStringIpv6() [][]netip. return s.RequiredDoubleArrayStringIpv6 } +// GetRequiredDoubleArrayStringMAC returns the value of RequiredDoubleArrayStringMAC. +func (s *TestResponseFormatTestOK) GetRequiredDoubleArrayStringMAC() [][]net.HardwareAddr { + return s.RequiredDoubleArrayStringMAC +} + // GetRequiredDoubleArrayStringPassword returns the value of RequiredDoubleArrayStringPassword. func (s *TestResponseFormatTestOK) GetRequiredDoubleArrayStringPassword() [][]string { return s.RequiredDoubleArrayStringPassword @@ -15327,6 +15630,11 @@ func (s *TestResponseFormatTestOK) GetRequiredStringIpv6() netip.Addr { return s.RequiredStringIpv6 } +// GetRequiredStringMAC returns the value of RequiredStringMAC. +func (s *TestResponseFormatTestOK) GetRequiredStringMAC() net.HardwareAddr { + return s.RequiredStringMAC +} + // GetRequiredStringPassword returns the value of RequiredStringPassword. func (s *TestResponseFormatTestOK) GetRequiredStringPassword() string { return s.RequiredStringPassword @@ -15612,6 +15920,11 @@ func (s *TestResponseFormatTestOK) GetOptionalArrayStringIpv6() []netip.Addr { return s.OptionalArrayStringIpv6 } +// GetOptionalArrayStringMAC returns the value of OptionalArrayStringMAC. +func (s *TestResponseFormatTestOK) GetOptionalArrayStringMAC() []net.HardwareAddr { + return s.OptionalArrayStringMAC +} + // GetOptionalArrayStringPassword returns the value of OptionalArrayStringPassword. func (s *TestResponseFormatTestOK) GetOptionalArrayStringPassword() []string { return s.OptionalArrayStringPassword @@ -15897,6 +16210,11 @@ func (s *TestResponseFormatTestOK) GetOptionalDoubleArrayStringIpv6() [][]netip. return s.OptionalDoubleArrayStringIpv6 } +// GetOptionalDoubleArrayStringMAC returns the value of OptionalDoubleArrayStringMAC. +func (s *TestResponseFormatTestOK) GetOptionalDoubleArrayStringMAC() [][]net.HardwareAddr { + return s.OptionalDoubleArrayStringMAC +} + // GetOptionalDoubleArrayStringPassword returns the value of OptionalDoubleArrayStringPassword. func (s *TestResponseFormatTestOK) GetOptionalDoubleArrayStringPassword() [][]string { return s.OptionalDoubleArrayStringPassword @@ -16167,6 +16485,11 @@ func (s *TestResponseFormatTestOK) GetOptionalStringIpv6() OptIPv6 { return s.OptionalStringIpv6 } +// GetOptionalStringMAC returns the value of OptionalStringMAC. +func (s *TestResponseFormatTestOK) GetOptionalStringMAC() OptHardwareAddr { + return s.OptionalStringMAC +} + // GetOptionalStringPassword returns the value of OptionalStringPassword. func (s *TestResponseFormatTestOK) GetOptionalStringPassword() OptString { return s.OptionalStringPassword @@ -16452,6 +16775,11 @@ func (s *TestResponseFormatTestOK) SetRequiredArrayStringIpv6(val []netip.Addr) s.RequiredArrayStringIpv6 = val } +// SetRequiredArrayStringMAC sets the value of RequiredArrayStringMAC. +func (s *TestResponseFormatTestOK) SetRequiredArrayStringMAC(val []net.HardwareAddr) { + s.RequiredArrayStringMAC = val +} + // SetRequiredArrayStringPassword sets the value of RequiredArrayStringPassword. func (s *TestResponseFormatTestOK) SetRequiredArrayStringPassword(val []string) { s.RequiredArrayStringPassword = val @@ -16737,6 +17065,11 @@ func (s *TestResponseFormatTestOK) SetRequiredDoubleArrayStringIpv6(val [][]neti s.RequiredDoubleArrayStringIpv6 = val } +// SetRequiredDoubleArrayStringMAC sets the value of RequiredDoubleArrayStringMAC. +func (s *TestResponseFormatTestOK) SetRequiredDoubleArrayStringMAC(val [][]net.HardwareAddr) { + s.RequiredDoubleArrayStringMAC = val +} + // SetRequiredDoubleArrayStringPassword sets the value of RequiredDoubleArrayStringPassword. func (s *TestResponseFormatTestOK) SetRequiredDoubleArrayStringPassword(val [][]string) { s.RequiredDoubleArrayStringPassword = val @@ -17007,6 +17340,11 @@ func (s *TestResponseFormatTestOK) SetRequiredStringIpv6(val netip.Addr) { s.RequiredStringIpv6 = val } +// SetRequiredStringMAC sets the value of RequiredStringMAC. +func (s *TestResponseFormatTestOK) SetRequiredStringMAC(val net.HardwareAddr) { + s.RequiredStringMAC = val +} + // SetRequiredStringPassword sets the value of RequiredStringPassword. func (s *TestResponseFormatTestOK) SetRequiredStringPassword(val string) { s.RequiredStringPassword = val @@ -17292,6 +17630,11 @@ func (s *TestResponseFormatTestOK) SetOptionalArrayStringIpv6(val []netip.Addr) s.OptionalArrayStringIpv6 = val } +// SetOptionalArrayStringMAC sets the value of OptionalArrayStringMAC. +func (s *TestResponseFormatTestOK) SetOptionalArrayStringMAC(val []net.HardwareAddr) { + s.OptionalArrayStringMAC = val +} + // SetOptionalArrayStringPassword sets the value of OptionalArrayStringPassword. func (s *TestResponseFormatTestOK) SetOptionalArrayStringPassword(val []string) { s.OptionalArrayStringPassword = val @@ -17577,6 +17920,11 @@ func (s *TestResponseFormatTestOK) SetOptionalDoubleArrayStringIpv6(val [][]neti s.OptionalDoubleArrayStringIpv6 = val } +// SetOptionalDoubleArrayStringMAC sets the value of OptionalDoubleArrayStringMAC. +func (s *TestResponseFormatTestOK) SetOptionalDoubleArrayStringMAC(val [][]net.HardwareAddr) { + s.OptionalDoubleArrayStringMAC = val +} + // SetOptionalDoubleArrayStringPassword sets the value of OptionalDoubleArrayStringPassword. func (s *TestResponseFormatTestOK) SetOptionalDoubleArrayStringPassword(val [][]string) { s.OptionalDoubleArrayStringPassword = val @@ -17847,6 +18195,11 @@ func (s *TestResponseFormatTestOK) SetOptionalStringIpv6(val OptIPv6) { s.OptionalStringIpv6 = val } +// SetOptionalStringMAC sets the value of OptionalStringMAC. +func (s *TestResponseFormatTestOK) SetOptionalStringMAC(val OptHardwareAddr) { + s.OptionalStringMAC = val +} + // SetOptionalStringPassword sets the value of OptionalStringPassword. func (s *TestResponseFormatTestOK) SetOptionalStringPassword(val OptString) { s.OptionalStringPassword = val diff --git a/examples/ex_test_format/oas_server_gen.go b/examples/ex_test_format/oas_server_gen.go index 8989b4a2f..5d08d82af 100644 --- a/examples/ex_test_format/oas_server_gen.go +++ b/examples/ex_test_format/oas_server_gen.go @@ -4,6 +4,7 @@ package api import ( "context" + "net" "net/netip" "net/url" "time" @@ -1542,6 +1543,30 @@ type Handler interface { // // POST /test_request_required_string_ipv6_nullable_array_array TestRequestRequiredStringIpv6NullableArrayArray(ctx context.Context, req [][]NilIPv6) (*Error, error) + // TestRequestRequiredStringMAC implements test_request_required_string_mac operation. + // + // POST /test_request_required_string_mac + TestRequestRequiredStringMAC(ctx context.Context, req net.HardwareAddr) (*Error, error) + // TestRequestRequiredStringMACArray implements test_request_required_string_mac_array operation. + // + // POST /test_request_required_string_mac_array + TestRequestRequiredStringMACArray(ctx context.Context, req []net.HardwareAddr) (*Error, error) + // TestRequestRequiredStringMACArrayArray implements test_request_required_string_mac_array_array operation. + // + // POST /test_request_required_string_mac_array_array + TestRequestRequiredStringMACArrayArray(ctx context.Context, req [][]net.HardwareAddr) (*Error, error) + // TestRequestRequiredStringMACNullable implements test_request_required_string_mac_nullable operation. + // + // POST /test_request_required_string_mac_nullable + TestRequestRequiredStringMACNullable(ctx context.Context, req NilHardwareAddr) (*Error, error) + // TestRequestRequiredStringMACNullableArray implements test_request_required_string_mac_nullable_array operation. + // + // POST /test_request_required_string_mac_nullable_array + TestRequestRequiredStringMACNullableArray(ctx context.Context, req []NilHardwareAddr) (*Error, error) + // TestRequestRequiredStringMACNullableArrayArray implements test_request_required_string_mac_nullable_array_array operation. + // + // POST /test_request_required_string_mac_nullable_array_array + TestRequestRequiredStringMACNullableArrayArray(ctx context.Context, req [][]NilHardwareAddr) (*Error, error) // TestRequestRequiredStringNullable implements test_request_required_string_nullable operation. // // POST /test_request_required_string_nullable @@ -2334,6 +2359,30 @@ type Handler interface { // // POST /test_request_string_ipv6_nullable_array_array TestRequestStringIpv6NullableArrayArray(ctx context.Context, req [][]NilIPv6) (*Error, error) + // TestRequestStringMAC implements test_request_string_mac operation. + // + // POST /test_request_string_mac + TestRequestStringMAC(ctx context.Context, req OptHardwareAddr) (*Error, error) + // TestRequestStringMACArray implements test_request_string_mac_array operation. + // + // POST /test_request_string_mac_array + TestRequestStringMACArray(ctx context.Context, req []net.HardwareAddr) (*Error, error) + // TestRequestStringMACArrayArray implements test_request_string_mac_array_array operation. + // + // POST /test_request_string_mac_array_array + TestRequestStringMACArrayArray(ctx context.Context, req [][]net.HardwareAddr) (*Error, error) + // TestRequestStringMACNullable implements test_request_string_mac_nullable operation. + // + // POST /test_request_string_mac_nullable + TestRequestStringMACNullable(ctx context.Context, req OptNilHardwareAddr) (*Error, error) + // TestRequestStringMACNullableArray implements test_request_string_mac_nullable_array operation. + // + // POST /test_request_string_mac_nullable_array + TestRequestStringMACNullableArray(ctx context.Context, req []NilHardwareAddr) (*Error, error) + // TestRequestStringMACNullableArrayArray implements test_request_string_mac_nullable_array_array operation. + // + // POST /test_request_string_mac_nullable_array_array + TestRequestStringMACNullableArrayArray(ctx context.Context, req [][]NilHardwareAddr) (*Error, error) // TestRequestStringNullable implements test_request_string_nullable operation. // // POST /test_request_string_nullable @@ -3666,6 +3715,30 @@ type Handler interface { // // POST /test_response_string_ipv6_nullable_array_array TestResponseStringIpv6NullableArrayArray(ctx context.Context, req string) ([][]NilIPv6, error) + // TestResponseStringMAC implements test_response_string_mac operation. + // + // POST /test_response_string_mac + TestResponseStringMAC(ctx context.Context, req string) (net.HardwareAddr, error) + // TestResponseStringMACArray implements test_response_string_mac_array operation. + // + // POST /test_response_string_mac_array + TestResponseStringMACArray(ctx context.Context, req string) ([]net.HardwareAddr, error) + // TestResponseStringMACArrayArray implements test_response_string_mac_array_array operation. + // + // POST /test_response_string_mac_array_array + TestResponseStringMACArrayArray(ctx context.Context, req string) ([][]net.HardwareAddr, error) + // TestResponseStringMACNullable implements test_response_string_mac_nullable operation. + // + // POST /test_response_string_mac_nullable + TestResponseStringMACNullable(ctx context.Context, req string) (NilHardwareAddr, error) + // TestResponseStringMACNullableArray implements test_response_string_mac_nullable_array operation. + // + // POST /test_response_string_mac_nullable_array + TestResponseStringMACNullableArray(ctx context.Context, req string) ([]NilHardwareAddr, error) + // TestResponseStringMACNullableArrayArray implements test_response_string_mac_nullable_array_array operation. + // + // POST /test_response_string_mac_nullable_array_array + TestResponseStringMACNullableArrayArray(ctx context.Context, req string) ([][]NilHardwareAddr, error) // TestResponseStringNullable implements test_response_string_nullable operation. // // POST /test_response_string_nullable diff --git a/examples/ex_test_format/oas_unimplemented_gen.go b/examples/ex_test_format/oas_unimplemented_gen.go index a33012cc9..775bca2d0 100644 --- a/examples/ex_test_format/oas_unimplemented_gen.go +++ b/examples/ex_test_format/oas_unimplemented_gen.go @@ -4,6 +4,7 @@ package api import ( "context" + "net" "net/netip" "net/url" "time" @@ -2693,6 +2694,48 @@ func (UnimplementedHandler) TestRequestRequiredStringIpv6NullableArrayArray(ctx return r, ht.ErrNotImplemented } +// TestRequestRequiredStringMAC implements test_request_required_string_mac operation. +// +// POST /test_request_required_string_mac +func (UnimplementedHandler) TestRequestRequiredStringMAC(ctx context.Context, req net.HardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredStringMACArray implements test_request_required_string_mac_array operation. +// +// POST /test_request_required_string_mac_array +func (UnimplementedHandler) TestRequestRequiredStringMACArray(ctx context.Context, req []net.HardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredStringMACArrayArray implements test_request_required_string_mac_array_array operation. +// +// POST /test_request_required_string_mac_array_array +func (UnimplementedHandler) TestRequestRequiredStringMACArrayArray(ctx context.Context, req [][]net.HardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredStringMACNullable implements test_request_required_string_mac_nullable operation. +// +// POST /test_request_required_string_mac_nullable +func (UnimplementedHandler) TestRequestRequiredStringMACNullable(ctx context.Context, req NilHardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredStringMACNullableArray implements test_request_required_string_mac_nullable_array operation. +// +// POST /test_request_required_string_mac_nullable_array +func (UnimplementedHandler) TestRequestRequiredStringMACNullableArray(ctx context.Context, req []NilHardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestRequiredStringMACNullableArrayArray implements test_request_required_string_mac_nullable_array_array operation. +// +// POST /test_request_required_string_mac_nullable_array_array +func (UnimplementedHandler) TestRequestRequiredStringMACNullableArrayArray(ctx context.Context, req [][]NilHardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + // TestRequestRequiredStringNullable implements test_request_required_string_nullable operation. // // POST /test_request_required_string_nullable @@ -4079,6 +4122,48 @@ func (UnimplementedHandler) TestRequestStringIpv6NullableArrayArray(ctx context. return r, ht.ErrNotImplemented } +// TestRequestStringMAC implements test_request_string_mac operation. +// +// POST /test_request_string_mac +func (UnimplementedHandler) TestRequestStringMAC(ctx context.Context, req OptHardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestStringMACArray implements test_request_string_mac_array operation. +// +// POST /test_request_string_mac_array +func (UnimplementedHandler) TestRequestStringMACArray(ctx context.Context, req []net.HardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestStringMACArrayArray implements test_request_string_mac_array_array operation. +// +// POST /test_request_string_mac_array_array +func (UnimplementedHandler) TestRequestStringMACArrayArray(ctx context.Context, req [][]net.HardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestStringMACNullable implements test_request_string_mac_nullable operation. +// +// POST /test_request_string_mac_nullable +func (UnimplementedHandler) TestRequestStringMACNullable(ctx context.Context, req OptNilHardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestStringMACNullableArray implements test_request_string_mac_nullable_array operation. +// +// POST /test_request_string_mac_nullable_array +func (UnimplementedHandler) TestRequestStringMACNullableArray(ctx context.Context, req []NilHardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + +// TestRequestStringMACNullableArrayArray implements test_request_string_mac_nullable_array_array operation. +// +// POST /test_request_string_mac_nullable_array_array +func (UnimplementedHandler) TestRequestStringMACNullableArrayArray(ctx context.Context, req [][]NilHardwareAddr) (r *Error, _ error) { + return r, ht.ErrNotImplemented +} + // TestRequestStringNullable implements test_request_string_nullable operation. // // POST /test_request_string_nullable @@ -6410,6 +6495,48 @@ func (UnimplementedHandler) TestResponseStringIpv6NullableArrayArray(ctx context return r, ht.ErrNotImplemented } +// TestResponseStringMAC implements test_response_string_mac operation. +// +// POST /test_response_string_mac +func (UnimplementedHandler) TestResponseStringMAC(ctx context.Context, req string) (r net.HardwareAddr, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseStringMACArray implements test_response_string_mac_array operation. +// +// POST /test_response_string_mac_array +func (UnimplementedHandler) TestResponseStringMACArray(ctx context.Context, req string) (r []net.HardwareAddr, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseStringMACArrayArray implements test_response_string_mac_array_array operation. +// +// POST /test_response_string_mac_array_array +func (UnimplementedHandler) TestResponseStringMACArrayArray(ctx context.Context, req string) (r [][]net.HardwareAddr, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseStringMACNullable implements test_response_string_mac_nullable operation. +// +// POST /test_response_string_mac_nullable +func (UnimplementedHandler) TestResponseStringMACNullable(ctx context.Context, req string) (r NilHardwareAddr, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseStringMACNullableArray implements test_response_string_mac_nullable_array operation. +// +// POST /test_response_string_mac_nullable_array +func (UnimplementedHandler) TestResponseStringMACNullableArray(ctx context.Context, req string) (r []NilHardwareAddr, _ error) { + return r, ht.ErrNotImplemented +} + +// TestResponseStringMACNullableArrayArray implements test_response_string_mac_nullable_array_array operation. +// +// POST /test_response_string_mac_nullable_array_array +func (UnimplementedHandler) TestResponseStringMACNullableArrayArray(ctx context.Context, req string) (r [][]NilHardwareAddr, _ error) { + return r, ht.ErrNotImplemented +} + // TestResponseStringNullable implements test_response_string_nullable operation. // // POST /test_response_string_nullable diff --git a/examples/ex_test_format/oas_validators_gen.go b/examples/ex_test_format/oas_validators_gen.go index 700f006a3..899b71dae 100644 --- a/examples/ex_test_format/oas_validators_gen.go +++ b/examples/ex_test_format/oas_validators_gen.go @@ -613,6 +613,17 @@ func (s *TestRequestFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredArrayStringMAC == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_string_mac", + Error: err, + }) + } if err := func() error { if s.RequiredArrayStringPassword == nil { return errors.New("nil is invalid value") @@ -2078,6 +2089,34 @@ func (s *TestRequestFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredDoubleArrayStringMAC == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayStringMAC { + 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_string_mac", + Error: err, + }) + } if err := func() error { if s.RequiredDoubleArrayStringPassword == nil { return errors.New("nil is invalid value") @@ -3939,6 +3978,31 @@ func (s *TestRequestFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayStringMAC { + 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_string_mac", + Error: err, + }) + } if err := func() error { var failures []validate.FieldError for i, elem := range s.OptionalDoubleArrayStringPassword { @@ -5040,6 +5104,17 @@ func (s *TestRequestRequiredFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredArrayStringMAC == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_string_mac", + Error: err, + }) + } if err := func() error { if s.RequiredArrayStringPassword == nil { return errors.New("nil is invalid value") @@ -6505,6 +6580,34 @@ func (s *TestRequestRequiredFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredDoubleArrayStringMAC == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayStringMAC { + 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_string_mac", + Error: err, + }) + } if err := func() error { if s.RequiredDoubleArrayStringPassword == nil { return errors.New("nil is invalid value") @@ -8366,6 +8469,31 @@ func (s *TestRequestRequiredFormatTestReq) Validate() error { Error: err, }) } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayStringMAC { + 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_string_mac", + Error: err, + }) + } if err := func() error { var failures []validate.FieldError for i, elem := range s.OptionalDoubleArrayStringPassword { @@ -9467,6 +9595,17 @@ func (s *TestResponseFormatTestOK) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredArrayStringMAC == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "required_array_string_mac", + Error: err, + }) + } if err := func() error { if s.RequiredArrayStringPassword == nil { return errors.New("nil is invalid value") @@ -10932,6 +11071,34 @@ func (s *TestResponseFormatTestOK) Validate() error { Error: err, }) } + if err := func() error { + if s.RequiredDoubleArrayStringMAC == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.RequiredDoubleArrayStringMAC { + 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_string_mac", + Error: err, + }) + } if err := func() error { if s.RequiredDoubleArrayStringPassword == nil { return errors.New("nil is invalid value") @@ -12793,6 +12960,31 @@ func (s *TestResponseFormatTestOK) Validate() error { Error: err, }) } + if err := func() error { + var failures []validate.FieldError + for i, elem := range s.OptionalDoubleArrayStringMAC { + 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_string_mac", + Error: err, + }) + } if err := func() error { var failures []validate.FieldError for i, elem := range s.OptionalDoubleArrayStringPassword { From cd89acd59e913ee7357a691e1025b0fa226e8682 Mon Sep 17 00:00:00 2001 From: tdakkota Date: Tue, 6 Feb 2024 07:38:20 +0300 Subject: [PATCH 4/6] fix(ir): use literal to fake MAC address --- gen/ir/faker.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gen/ir/faker.go b/gen/ir/faker.go index 60c06537b..32ad3f2a5 100644 --- a/gen/ir/faker.go +++ b/gen/ir/faker.go @@ -32,7 +32,7 @@ func (t *Type) FakeValue() string { case UUID: return "uuid.New()" case MAC: - return `net.ParseMAC("11:22:33:44:55:66")` + return `net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}` case IP: if s := t.Schema; s != nil && s.Format == "ipv6" { return `netip.MustParseAddr("::1")` From 107d9fbca389cd98c34559cf3974a86947121a24 Mon Sep 17 00:00:00 2001 From: tdakkota Date: Tue, 6 Feb 2024 07:41:06 +0300 Subject: [PATCH 5/6] fix(ir): use right function for string parsing --- gen/ir/template_helpers.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gen/ir/template_helpers.go b/gen/ir/template_helpers.go index db8a73579..218ca1a9f 100644 --- a/gen/ir/template_helpers.go +++ b/gen/ir/template_helpers.go @@ -52,6 +52,8 @@ func (t Type) uriFormat() string { return naming.Capitalize(f) case "date-time": return "DateTime" + case "mac": + return "MAC" case "int8", "int16", "int32", From 9c84f12f2178620d098cdbb53272d9681dbd4f17 Mon Sep 17 00:00:00 2001 From: tdakkota Date: Tue, 6 Feb 2024 07:41:11 +0300 Subject: [PATCH 6/6] chore: commit generated files --- examples/ex_test_format/oas_client_gen.go | 4 +-- examples/ex_test_format/oas_faker_gen.go | 32 +++++++++---------- examples/ex_test_format/oas_parameters_gen.go | 4 +-- 3 files changed, 20 insertions(+), 20 deletions(-) diff --git a/examples/ex_test_format/oas_client_gen.go b/examples/ex_test_format/oas_client_gen.go index 2c077cb0d..c51b65a46 100644 --- a/examples/ex_test_format/oas_client_gen.go +++ b/examples/ex_test_format/oas_client_gen.go @@ -5688,7 +5688,7 @@ func (c *Client) sendTestQueryParameter(ctx context.Context, request string, par } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.HardwareAddrToString(params.StringMAC)) + return e.EncodeValue(conv.MACToString(params.StringMAC)) }); err != nil { return res, errors.Wrap(err, "encode query") } @@ -5705,7 +5705,7 @@ func (c *Client) sendTestQueryParameter(ctx context.Context, request string, par return e.EncodeArray(func(e uri.Encoder) error { for i, item := range params.StringMACArray { if err := func() error { - return e.EncodeValue(conv.HardwareAddrToString(item)) + return e.EncodeValue(conv.MACToString(item)) }(); err != nil { return errors.Wrapf(err, "[%d]", i) } diff --git a/examples/ex_test_format/oas_faker_gen.go b/examples/ex_test_format/oas_faker_gen.go index ed1b373fb..2b1af2cc9 100644 --- a/examples/ex_test_format/oas_faker_gen.go +++ b/examples/ex_test_format/oas_faker_gen.go @@ -304,7 +304,7 @@ func (s *OptFloat64) SetFake() { func (s *OptHardwareAddr) SetFake() { var elem net.HardwareAddr { - elem = net.ParseMAC("11:22:33:44:55:66") + elem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } s.SetTo(elem) } @@ -1451,7 +1451,7 @@ func (s *TestRequestFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elem net.HardwareAddr { - elem = net.ParseMAC("11:22:33:44:55:66") + elem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) } @@ -2438,7 +2438,7 @@ func (s *TestRequestFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elemElem net.HardwareAddr { - elemElem = net.ParseMAC("11:22:33:44:55:66") + elemElem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } elem = append(elem, elemElem) } @@ -2915,7 +2915,7 @@ func (s *TestRequestFormatTestReq) SetFake() { } { { - s.RequiredStringMAC = net.ParseMAC("11:22:33:44:55:66") + s.RequiredStringMAC = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } } { @@ -3503,7 +3503,7 @@ func (s *TestRequestFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elem net.HardwareAddr { - elem = net.ParseMAC("11:22:33:44:55:66") + elem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) } @@ -4490,7 +4490,7 @@ func (s *TestRequestFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elemElem net.HardwareAddr { - elemElem = net.ParseMAC("11:22:33:44:55:66") + elemElem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } elem = append(elem, elemElem) } @@ -5563,7 +5563,7 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elem net.HardwareAddr { - elem = net.ParseMAC("11:22:33:44:55:66") + elem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) } @@ -6550,7 +6550,7 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elemElem net.HardwareAddr { - elemElem = net.ParseMAC("11:22:33:44:55:66") + elemElem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } elem = append(elem, elemElem) } @@ -7027,7 +7027,7 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { } { { - s.RequiredStringMAC = net.ParseMAC("11:22:33:44:55:66") + s.RequiredStringMAC = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } } { @@ -7615,7 +7615,7 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elem net.HardwareAddr { - elem = net.ParseMAC("11:22:33:44:55:66") + elem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) } @@ -8602,7 +8602,7 @@ func (s *TestRequestRequiredFormatTestReq) SetFake() { for i := 0; i < 0; i++ { var elemElem net.HardwareAddr { - elemElem = net.ParseMAC("11:22:33:44:55:66") + elemElem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } elem = append(elem, elemElem) } @@ -9675,7 +9675,7 @@ func (s *TestResponseFormatTestOK) SetFake() { for i := 0; i < 0; i++ { var elem net.HardwareAddr { - elem = net.ParseMAC("11:22:33:44:55:66") + elem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } s.RequiredArrayStringMAC = append(s.RequiredArrayStringMAC, elem) } @@ -10662,7 +10662,7 @@ func (s *TestResponseFormatTestOK) SetFake() { for i := 0; i < 0; i++ { var elemElem net.HardwareAddr { - elemElem = net.ParseMAC("11:22:33:44:55:66") + elemElem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } elem = append(elem, elemElem) } @@ -11139,7 +11139,7 @@ func (s *TestResponseFormatTestOK) SetFake() { } { { - s.RequiredStringMAC = net.ParseMAC("11:22:33:44:55:66") + s.RequiredStringMAC = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } } { @@ -11727,7 +11727,7 @@ func (s *TestResponseFormatTestOK) SetFake() { for i := 0; i < 0; i++ { var elem net.HardwareAddr { - elem = net.ParseMAC("11:22:33:44:55:66") + elem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } s.OptionalArrayStringMAC = append(s.OptionalArrayStringMAC, elem) } @@ -12714,7 +12714,7 @@ func (s *TestResponseFormatTestOK) SetFake() { for i := 0; i < 0; i++ { var elemElem net.HardwareAddr { - elemElem = net.ParseMAC("11:22:33:44:55:66") + elemElem = net.HardwareAddr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66} } elem = append(elem, elemElem) } diff --git a/examples/ex_test_format/oas_parameters_gen.go b/examples/ex_test_format/oas_parameters_gen.go index 8e791999d..b74b4d461 100644 --- a/examples/ex_test_format/oas_parameters_gen.go +++ b/examples/ex_test_format/oas_parameters_gen.go @@ -4692,7 +4692,7 @@ func decodeTestQueryParameterParams(args [0]string, argsEscaped bool, r *http.Re return err } - c, err := conv.ToHardwareAddr(val) + c, err := conv.ToMAC(val) if err != nil { return err } @@ -4731,7 +4731,7 @@ func decodeTestQueryParameterParams(args [0]string, argsEscaped bool, r *http.Re return err } - c, err := conv.ToHardwareAddr(val) + c, err := conv.ToMAC(val) if err != nil { return err }